src/third_party/icu/source/test/cintltst/cbiditst.c

   1 /********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 1997-2013, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ********************************************************************/
   6 /*   file name:  cbiditst.c
   7 *   encoding:   US-ASCII
   8 *   tab size:   8 (not used)
   9 *   indentation:4
  10 *
  11 *   created on: 1999sep27
  12 *   created by: Markus W. Scherer, updated by Matitiahu Allouche
  13 */
  14
  15 #include "cintltst.h"
  16 #include "unicode/utypes.h"
  17 #include "unicode/uchar.h"
  18 #include "unicode/ustring.h"
  19 #include "unicode/ubidi.h"
  20 #include "unicode/ushape.h"
  21 #include "cbiditst.h"
  22 #include "cstring.h"
  23 /* the following include is needed for sprintf */
  24 #include <stdio.h>
  25
  26 #define MAXLEN      MAX_STRING_LENGTH
  27 #define LENGTHOF(array) (sizeof(array)/sizeof((array)[0]))
  28
  29 /* prototypes ---------------------------------------------------------------*/
  30
  31 void addComplexTest(TestNode** root);
  32
  33 static void testCharFromDirProp(void);
  34
  35 static void testBidi(void);
  36
  37 static void doTests(UBiDi *pBiDi, UBiDi *pLine, UBool countRunsFirst);
  38
  39 static void doMisc(void);
  40
  41 static void doTest(UBiDi *pBiDi, int testNumber, const BiDiTestData *test,
  42                    int32_t lineStart, UBool countRunsFirst);
  43
  44 static void _testReordering(UBiDi *pBiDi, int testNumber);
  45
  46 static void testInverse(void);
  47
  48 static void _testManyInverseBidi(UBiDi *pBiDi, UBiDiLevel direction);
  49
  50 static void _testInverseBidi(UBiDi *pBiDi, const UChar *src, int32_t srcLength,
  51                              UBiDiLevel direction, UErrorCode *pErrorCode);
  52
  53 static void _testWriteReverse(void);
  54
  55 static void _testManyAddedPoints(void);
  56
  57 static void _testMisc(void);
  58
  59 static void doArabicShapingTest(void);
  60
  61 static void doLamAlefSpecialVLTRArabicShapingTest(void);
  62
  63 static void doTashkeelSpecialVLTRArabicShapingTest(void);
  64
  65 static void doLOGICALArabicDeShapingTest(void);
  66
  67 static void doArabicShapingTestForBug5421(void);
  68
  69 static void doArabicShapingTestForBug8703(void);
  70
  71 static void doArabicShapingTestForBug9024(void);
  72
  73 static void testReorder(void);
  74
  75 static void testReorderArabicMathSymbols(void);
  76
  77 static void testFailureRecovery(void);
  78
  79 static void testMultipleParagraphs(void);
  80
  81 static void testGetBaseDirection(void);
  82
  83 static void testContext(void);
  84
  85 static void doTailTest(void);
  86
  87 /* new BIDI API */
  88 static void testReorderingMode(void);
  89 static void testReorderRunsOnly(void);
  90 static void testStreaming(void);
  91 static void testClassOverride(void);
  92 static const char* inverseBasic(UBiDi *pBiDi, const char *src, int32_t srcLen,
  93                                 uint32_t option, UBiDiLevel level, char *result);
  94 static UBool assertRoundTrip(UBiDi *pBiDi, int32_t tc, int32_t outIndex,
  95                              const char *srcChars, const char *destChars,
  96                              const UChar *dest, int32_t destLen, int mode,
  97                              int option, UBiDiLevel level);
  98 static UBool checkResultLength(UBiDi *pBiDi, const char *srcChars,
  99                                const char *destChars,
 100                                int32_t destLen, const char *mode,
 101                                const char *option, UBiDiLevel level);
 102 static UBool checkMaps(UBiDi *pBiDi, int32_t stringIndex, const char *src,
 103                        const char *dest, const char *mode, const char* option,
 104                        UBiDiLevel level, UBool forward);
 105
 106 /* helpers ------------------------------------------------------------------ */
 107
 108 static const char *levelString="...............................................................";
 109
 110 static void initCharFromDirProps(void);
 111
 112 static UChar *
 113 getStringFromDirProps(const uint8_t *dirProps, int32_t length, UChar *buffer);
 114
 115 static void printUnicode(const UChar *s, int32_t length, const UBiDiLevel *levels);
 116
 117 /* regression tests ---------------------------------------------------------*/
 118
 119 void
 120 addComplexTest(TestNode** root) {
 121     addTest(root, testCharFromDirProp, "complex/bidi/TestCharFromDirProp");
 122     addTest(root, testBidi, "complex/bidi/TestBidi");
 123     addTest(root, testInverse, "complex/bidi/TestInverse");
 124     addTest(root, testReorder,"complex/bidi/TestReorder");
 125     addTest(root, testFailureRecovery,"complex/bidi/TestFailureRecovery");
 126     addTest(root, testMultipleParagraphs,"complex/bidi/TestMultipleParagraphs");
 127     addTest(root, testReorderingMode, "complex/bidi/TestReorderingMode");
 128     addTest(root, testReorderRunsOnly, "complex/bidi/TestReorderRunsOnly");
 129     addTest(root, testStreaming, "complex/bidi/TestStreaming");
 130     addTest(root, testClassOverride, "complex/bidi/TestClassOverride");
 131     addTest(root, testGetBaseDirection, "complex/bidi/testGetBaseDirection");
 132     addTest(root, testContext, "complex/bidi/testContext");
 133
 134     addTest(root, doArabicShapingTest, "complex/arabic-shaping/ArabicShapingTest");
 135     addTest(root, doLamAlefSpecialVLTRArabicShapingTest, "complex/arabic-shaping/lamalef");
 136     addTest(root, doTashkeelSpecialVLTRArabicShapingTest, "complex/arabic-shaping/tashkeel");
 137     addTest(root, doLOGICALArabicDeShapingTest, "complex/arabic-shaping/unshaping");
 138     addTest(root, doArabicShapingTestForBug5421, "complex/arabic-shaping/bug-5421");
 139     addTest(root, doTailTest, "complex/arabic-shaping/tailtest");
 140     addTest(root, doArabicShapingTestForBug8703, "complex/arabic-shaping/bug-8703");
 141     addTest(root, testReorderArabicMathSymbols, "complex/bidi/bug-9024");
 142     addTest(root, doArabicShapingTestForBug9024, "complex/arabic-shaping/bug-9024");
 143 }
 144
 145 static void
 146 testCharFromDirProp(void) {
 147     /* verify that the exemplar characters have the expected bidi classes */
 148     int32_t i;
 149
 150     log_verbose("\nEntering TestCharFromDirProp\n\n");
 151     initCharFromDirProps();
 152
 153     for(i=0; i<U_CHAR_DIRECTION_COUNT; ++i) {
 154         if(u_charDirection(charFromDirProp[i])!=(UCharDirection)i) {
 155             log_err("\nu_charDirection(charFromDirProp[%d]=U+%04x)==%d!=%d\n",
 156                     i, charFromDirProp[i], u_charDirection(charFromDirProp[i]), i);
 157         }
 158     }
 159     log_verbose("\nExiting TestCharFromDirProp\n\n");
 160 }
 161
 162 static void
 163 testBidi(void) {
 164     UBiDi *pBiDi, *pLine=NULL;
 165     UErrorCode errorCode=U_ZERO_ERROR;
 166
 167     log_verbose("\nEntering TestBidi\n\n");
 168
 169     pBiDi=ubidi_openSized(MAXLEN, 0, &errorCode);
 170     if(pBiDi!=NULL) {
 171         pLine=ubidi_open();
 172         if(pLine!=NULL) {
 173             doTests(pBiDi, pLine, FALSE);
 174             doTests(pBiDi, pLine, TRUE);
 175         } else {
 176             log_err("ubidi_open() returned NULL, out of memory\n");
 177         }
 178     } else {
 179         log_err("ubidi_openSized() returned NULL, errorCode %s\n", myErrorName(errorCode));
 180     }
 181     doMisc();
 182
 183     if(pLine!=NULL) {
 184         ubidi_close(pLine);
 185     }
 186     if(pBiDi!=NULL) {
 187         ubidi_close(pBiDi);
 188     }
 189
 190     log_verbose("\nExiting TestBidi\n\n");
 191 }
 192
 193 static void
 194 doTests(UBiDi *pBiDi, UBiDi *pLine, UBool countRunsFirst) {
 195     int testNumber;
 196     UChar string[MAXLEN];
 197     UErrorCode errorCode;
 198     int32_t lineStart;
 199     UBiDiLevel paraLevel;
 200
 201     for(testNumber=0; testNumber<bidiTestCount; ++testNumber) {
 202         errorCode=U_ZERO_ERROR;
 203         getStringFromDirProps(tests[testNumber].text, tests[testNumber].length, string);
 204         paraLevel=tests[testNumber].paraLevel;
 205         ubidi_setPara(pBiDi, string, -1, paraLevel, NULL, &errorCode);
 206         if(U_SUCCESS(errorCode)) {
 207             log_verbose("ubidi_setPara(tests[%d], paraLevel %d) ok, direction %d paraLevel=%d\n",
 208                     testNumber, paraLevel, ubidi_getDirection(pBiDi), paraLevel);
 209             lineStart=tests[testNumber].lineStart;
 210             if(lineStart==-1) {
 211                 doTest(pBiDi, testNumber, tests+testNumber, 0, countRunsFirst);
 212             } else {
 213                 ubidi_setLine(pBiDi, lineStart, tests[testNumber].lineLimit, pLine, &errorCode);
 214                 if(U_SUCCESS(errorCode)) {
 215                     log_verbose("ubidi_setLine(%d, %d) ok, direction %d paraLevel=%d\n",
 216                             lineStart, tests[testNumber].lineLimit, ubidi_getDirection(pLine), ubidi_getParaLevel(pLine));
 217                     doTest(pLine, testNumber, tests+testNumber, lineStart, countRunsFirst);
 218                 } else {
 219                     log_err("ubidi_setLine(tests[%d], %d, %d) failed with errorCode %s\n",
 220                             testNumber, lineStart, tests[testNumber].lineLimit, myErrorName(errorCode));
 221                 }
 222             }
 223         } else {
 224             log_err("ubidi_setPara(tests[%d], paraLevel %d) failed with errorCode %s\n",
 225                     testNumber, paraLevel, myErrorName(errorCode));
 226         }
 227     }
 228 }
 229
 230 static const char columns[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 231
 232 #define TABLE_SIZE  256
 233 static UBool   tablesInitialized = FALSE;
 234 static UChar   pseudoToUChar[TABLE_SIZE];
 235 static uint8_t UCharToPseudo[TABLE_SIZE];    /* used for Unicode chars < 0x0100 */
 236 static uint8_t UCharToPseud2[TABLE_SIZE];    /* used for Unicode chars >=0x0100 */
 237
 238 static void buildPseudoTables(void)
 239 /*
 240     The rules for pseudo-Bidi are as follows:
 241     - [ == LRE
 242     - ] == RLE
 243     - { == LRO
 244     - } == RLO
 245     - ^ == PDF
 246     - @ == LRM
 247     - & == RLM
 248     - A-F == Arabic Letters 0631-0636
 249     - G-V == Hebrew letters 05d7-05e6
 250     - W-Z == Unassigned RTL 08d0-08d3
 251     - 0-5 == western digits 0030-0035
 252     - 6-9 == Arabic-Indic digits 0666-0669
 253     - ` == Combining Grave Accent 0300 (NSM)
 254     - ~ == Delete 007f (BN)
 255     - | == Paragraph Separator 2029 (B)
 256     - _ == Info Separator 1 001f (S)
 257     All other characters represent themselves as Latin-1, with the corresponding
 258     Bidi properties.
 259 */
 260 {
 261     int             i;
 262     UChar           uchar;
 263     uint8_t         c;
 264     /* initialize all tables to unknown */
 265     for (i=0; i < TABLE_SIZE; i++) {
 266         pseudoToUChar[i] = 0xFFFD;
 267         UCharToPseudo[i] = '?';
 268         UCharToPseud2[i] = '?';
 269     }
 270     /* initialize non letters or digits */
 271     pseudoToUChar[(uint8_t) 0 ] = 0x0000;    UCharToPseudo[0x00] = (uint8_t) 0 ;
 272     pseudoToUChar[(uint8_t)' '] = 0x0020;    UCharToPseudo[0x20] = (uint8_t)' ';
 273     pseudoToUChar[(uint8_t)'!'] = 0x0021;    UCharToPseudo[0x21] = (uint8_t)'!';
 274     pseudoToUChar[(uint8_t)'"'] = 0x0022;    UCharToPseudo[0x22] = (uint8_t)'"';
 275     pseudoToUChar[(uint8_t)'#'] = 0x0023;    UCharToPseudo[0x23] = (uint8_t)'#';
 276     pseudoToUChar[(uint8_t)'$'] = 0x0024;    UCharToPseudo[0x24] = (uint8_t)'$';
 277     pseudoToUChar[(uint8_t)'%'] = 0x0025;    UCharToPseudo[0x25] = (uint8_t)'%';
 278     pseudoToUChar[(uint8_t)'\'']= 0x0027;    UCharToPseudo[0x27] = (uint8_t)'\'';
 279     pseudoToUChar[(uint8_t)'('] = 0x0028;    UCharToPseudo[0x28] = (uint8_t)'(';
 280     pseudoToUChar[(uint8_t)')'] = 0x0029;    UCharToPseudo[0x29] = (uint8_t)')';
 281     pseudoToUChar[(uint8_t)'*'] = 0x002A;    UCharToPseudo[0x2A] = (uint8_t)'*';
 282     pseudoToUChar[(uint8_t)'+'] = 0x002B;    UCharToPseudo[0x2B] = (uint8_t)'+';
 283     pseudoToUChar[(uint8_t)','] = 0x002C;    UCharToPseudo[0x2C] = (uint8_t)',';
 284     pseudoToUChar[(uint8_t)'-'] = 0x002D;    UCharToPseudo[0x2D] = (uint8_t)'-';
 285     pseudoToUChar[(uint8_t)'.'] = 0x002E;    UCharToPseudo[0x2E] = (uint8_t)'.';
 286     pseudoToUChar[(uint8_t)'/'] = 0x002F;    UCharToPseudo[0x2F] = (uint8_t)'/';
 287     pseudoToUChar[(uint8_t)':'] = 0x003A;    UCharToPseudo[0x3A] = (uint8_t)':';
 288     pseudoToUChar[(uint8_t)';'] = 0x003B;    UCharToPseudo[0x3B] = (uint8_t)';';
 289     pseudoToUChar[(uint8_t)'<'] = 0x003C;    UCharToPseudo[0x3C] = (uint8_t)'<';
 290     pseudoToUChar[(uint8_t)'='] = 0x003D;    UCharToPseudo[0x3D] = (uint8_t)'=';
 291     pseudoToUChar[(uint8_t)'>'] = 0x003E;    UCharToPseudo[0x3E] = (uint8_t)'>';
 292     pseudoToUChar[(uint8_t)'?'] = 0x003F;    UCharToPseudo[0x3F] = (uint8_t)'?';
 293     pseudoToUChar[(uint8_t)'\\']= 0x005C;    UCharToPseudo[0x5C] = (uint8_t)'\\';
 294     /* initialize specially used characters */
 295     pseudoToUChar[(uint8_t)'`'] = 0x0300;    UCharToPseud2[0x00] = (uint8_t)'`';  /* NSM */
 296     pseudoToUChar[(uint8_t)'@'] = 0x200E;    UCharToPseud2[0x0E] = (uint8_t)'@';  /* LRM */
 297     pseudoToUChar[(uint8_t)'&'] = 0x200F;    UCharToPseud2[0x0F] = (uint8_t)'&';  /* RLM */
 298     pseudoToUChar[(uint8_t)'_'] = 0x001F;    UCharToPseudo[0x1F] = (uint8_t)'_';  /* S   */
 299     pseudoToUChar[(uint8_t)'|'] = 0x2029;    UCharToPseud2[0x29] = (uint8_t)'|';  /* B   */
 300     pseudoToUChar[(uint8_t)'['] = 0x202A;    UCharToPseud2[0x2A] = (uint8_t)'[';  /* LRE */
 301     pseudoToUChar[(uint8_t)']'] = 0x202B;    UCharToPseud2[0x2B] = (uint8_t)']';  /* RLE */
 302     pseudoToUChar[(uint8_t)'^'] = 0x202C;    UCharToPseud2[0x2C] = (uint8_t)'^';  /* PDF */
 303     pseudoToUChar[(uint8_t)'{'] = 0x202D;    UCharToPseud2[0x2D] = (uint8_t)'{';  /* LRO */
 304     pseudoToUChar[(uint8_t)'}'] = 0x202E;    UCharToPseud2[0x2E] = (uint8_t)'}';  /* RLO */
 305     pseudoToUChar[(uint8_t)'~'] = 0x007F;    UCharToPseudo[0x7F] = (uint8_t)'~';  /* BN  */
 306     /* initialize western digits */
 307     for (i = 0, uchar = 0x0030; i < 6; i++, uchar++) {
 308         c = (uint8_t)columns[i];
 309         pseudoToUChar[c] = uchar;
 310         UCharToPseudo[uchar & 0x00ff] = c;
 311     }
 312     /* initialize Hindi digits */
 313     for (i = 6, uchar = 0x0666; i < 10; i++, uchar++) {
 314         c = (uint8_t)columns[i];
 315         pseudoToUChar[c] = uchar;
 316         UCharToPseud2[uchar & 0x00ff] = c;
 317     }
 318     /* initialize Arabic letters */
 319     for (i = 10, uchar = 0x0631; i < 16; i++, uchar++) {
 320         c = (uint8_t)columns[i];
 321         pseudoToUChar[c] = uchar;
 322         UCharToPseud2[uchar & 0x00ff] = c;
 323     }
 324     /* initialize Hebrew letters */
 325     for (i = 16, uchar = 0x05D7; i < 32; i++, uchar++) {
 326         c = (uint8_t)columns[i];
 327         pseudoToUChar[c] = uchar;
 328         UCharToPseud2[uchar & 0x00ff] = c;
 329     }
 330     /* initialize Unassigned code points */
 331     for (i = 32, uchar=0x08D0; i < 36; i++, uchar++) {
 332         c = (uint8_t)columns[i];
 333         pseudoToUChar[c] = uchar;
 334         UCharToPseud2[uchar & 0x00ff] = c;
 335     }
 336     /* initialize Latin lower case letters */
 337     for (i = 36, uchar = 0x0061; i < 62; i++, uchar++) {
 338         c = (uint8_t)columns[i];
 339         pseudoToUChar[c] = uchar;
 340         UCharToPseudo[uchar & 0x00ff] = c;
 341     }
 342     tablesInitialized = TRUE;
 343 }
 344
 345 /*----------------------------------------------------------------------*/
 346
 347 static int pseudoToU16(const int length, const char * input, UChar * output)
 348 /*  This function converts a pseudo-Bidi string into a UChar string.
 349     It returns the length of the UChar string.
 350 */
 351 {
 352     int             i;
 353     if (!tablesInitialized) {
 354         buildPseudoTables();
 355     }
 356     for (i = 0; i < length; i++)
 357         output[i] = pseudoToUChar[(uint8_t)input[i]];
 358     output[length] = 0;
 359     return length;
 360 }
 361
 362 /*----------------------------------------------------------------------*/
 363
 364 static int u16ToPseudo(const int length, const UChar * input, char * output)
 365 /*  This function converts a UChar string into a pseudo-Bidi string.
 366     It returns the length of the pseudo-Bidi string.
 367 */
 368 {
 369     int             i;
 370     UChar           uchar;
 371     if (!tablesInitialized) {
 372         buildPseudoTables();
 373     }
 374     for (i = 0; i < length; i++)
 375     {
 376         uchar = input[i];
 377         output[i] = uchar < 0x0100 ? UCharToPseudo[uchar] :
 378                                         UCharToPseud2[uchar & 0x00ff];
 379     }
 380     output[length] = '\0';
 381     return length;
 382 }
 383
 384 static char * formatLevels(UBiDi *bidi, char *buffer) {
 385     UErrorCode ec = U_ZERO_ERROR;
 386     const UBiDiLevel* gotLevels = ubidi_getLevels(bidi, &ec);
 387     int len = ubidi_getLength(bidi);
 388     char c;
 389     int i, k;
 390
 391     if(U_FAILURE(ec)) {
 392         strcpy(buffer, "BAD LEVELS");
 393         return buffer;
 394     }
 395     for (i=0; i<len; i++) {
 396         k = gotLevels[i];
 397         if (k >= sizeof(columns))
 398             c = '+';
 399         else
 400             c = columns[k];
 401         buffer[i] = c;
 402     }
 403     buffer[len] = '\0';
 404     return buffer;
 405 }
 406 static const char *reorderingModeNames[] = {
 407     "UBIDI_REORDER_DEFAULT",
 408     "UBIDI_REORDER_NUMBERS_SPECIAL",
 409     "UBIDI_REORDER_GROUP_NUMBERS_WITH_R",
 410     "UBIDI_REORDER_RUNS_ONLY",
 411     "UBIDI_REORDER_INVERSE_NUMBERS_AS_L",
 412     "UBIDI_REORDER_INVERSE_LIKE_DIRECT",
 413     "UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL"};
 414
 415 static char *reorderingOptionNames(char *buffer, int options) {
 416     buffer[0] = 0;
 417     if (options & UBIDI_OPTION_INSERT_MARKS) {
 418         strcat(buffer, " UBIDI_OPTION_INSERT_MARKS");
 419     }
 420     if (options & UBIDI_OPTION_REMOVE_CONTROLS) {
 421         strcat(buffer, " UBIDI_OPTION_REMOVE_CONTROLS");
 422     }
 423     if (options & UBIDI_OPTION_STREAMING) {
 424         strcat(buffer, " UBIDI_OPTION_STREAMING");
 425     }
 426     return buffer;
 427 }
 428
 429 static void printCaseInfo(UBiDi *bidi, const char *src, const char *dst)
 430 /* src and dst are char arrays encoded as pseudo Bidi */
 431 {
 432     /* Since calls to log_err with a \n within the pattern increment the
 433      * error count, new lines are issued via fputs, except when we want the
 434      * increment to happen.
 435      */
 436     UErrorCode errorCode=U_ZERO_ERROR;
 437     int32_t i, length = ubidi_getProcessedLength(bidi);
 438     const UBiDiLevel *levels;
 439     char levelChars[MAXLEN];
 440     UBiDiLevel lev;
 441     int32_t runCount;
 442     char buffer[100];
 443     log_err("========================================"); fputs("\n", stderr);
 444     levels = ubidi_getLevels(bidi, &errorCode);
 445     if (U_FAILURE(errorCode)) {
 446         strcpy(levelChars, "BAD LEVELS");
 447     } else {
 448         log_err("Processed length: %d", length); fputs("\n", stderr);
 449         for (i = 0; i < length; i++) {
 450             lev = levels[i];
 451             if (lev < sizeof(columns)) {
 452                 levelChars[i] = columns[lev];
 453             } else {
 454                 levelChars[i] = '+';
 455             }
 456         }
 457         levelChars[length] = 0;
 458     }
 459     log_err("Levels: %s", levelChars); fputs("\n", stderr);
 460     log_err("Source: %s", src); fputs("\n", stderr);
 461     log_err("Result: %s", dst); fputs("\n", stderr);
 462     log_err("Direction: %d", ubidi_getDirection(bidi)); fputs("\n", stderr);
 463     log_err("paraLevel: %d", ubidi_getParaLevel(bidi)); fputs("\n", stderr);
 464     i = ubidi_getReorderingMode(bidi);
 465     log_err("reorderingMode: %d = %s", i, reorderingModeNames[i]);
 466     fputs("\n", stderr);
 467     i = ubidi_getReorderingOptions(bidi);
 468     log_err("reorderingOptions: %d = %s", i, reorderingOptionNames(buffer, i));
 469     fputs("\n", stderr);
 470     runCount = ubidi_countRuns(bidi, &errorCode);
 471     if (U_FAILURE(errorCode)) {
 472         log_err( "BAD RUNS");
 473     } else {
 474         log_err("Runs: %d => logicalStart.length/level: ", runCount);
 475         for (i = 0; i < runCount; i++) {
 476             UBiDiDirection dir;
 477             int32_t start, len;
 478             dir = ubidi_getVisualRun(bidi, i, &start, &len);
 479             log_err(" %d.%d/%d", start, len, dir);
 480         }
 481     }
 482     fputs("\n", stderr);
 483 }
 484
 485 static UBool matchingPair(UBiDi *bidi, int32_t i, char c1, char c2)
 486 {
 487     /* No test for []{} since they have special meaning for pseudo Bidi */
 488     static char mates1Chars[] = "<>()";
 489     static char mates2Chars[] = "><)(";
 490     UBiDiLevel level;
 491     int k, len;
 492
 493     if (c1 == c2) {
 494         return TRUE;
 495     }
 496     /* For UBIDI_REORDER_RUNS_ONLY, it would not be correct to check levels[i],
 497        so we use the appropriate run's level, which is good for all cases.
 498      */
 499     ubidi_getLogicalRun(bidi, i, NULL, &level);
 500     if ((level & 1) == 0) {
 501         return FALSE;
 502     }
 503     len = strlen(mates1Chars);
 504     for (k = 0; k < len; k++) {
 505         if ((c1 == mates1Chars[k]) && (c2 == mates2Chars[k])) {
 506             return TRUE;
 507         }
 508     }
 509     return FALSE;
 510 }
 511
 512 static UBool checkWhatYouCan(UBiDi *bidi, const char *srcChars, const char *dstChars)
 513 /* srcChars and dstChars are char arrays encoded as pseudo Bidi */
 514 {
 515     int32_t i, idx, logLimit, visLimit;
 516     UBool testOK, errMap, errDst;
 517     UErrorCode errorCode=U_ZERO_ERROR;
 518     int32_t visMap[MAXLEN];
 519     int32_t logMap[MAXLEN];
 520     char accumSrc[MAXLEN];
 521     char accumDst[MAXLEN];
 522     ubidi_getVisualMap(bidi, visMap, &errorCode);
 523     ubidi_getLogicalMap(bidi, logMap, &errorCode);
 524     if (U_FAILURE(errorCode)) {
 525         log_err("Error #1 invoking ICU within checkWhatYouCan\n");
 526         return FALSE;
 527     }
 528
 529     testOK = TRUE;
 530     errMap = errDst = FALSE;
 531     logLimit = ubidi_getProcessedLength(bidi);
 532     visLimit = ubidi_getResultLength(bidi);
 533     memset(accumSrc, '?', logLimit);
 534     memset(accumDst, '?', visLimit);
 535
 536     for (i = 0; i < logLimit; i++) {
 537         idx = ubidi_getVisualIndex(bidi, i, &errorCode);
 538         if (idx != logMap[i]) {
 539             errMap = TRUE;
 540         }
 541         if (idx == UBIDI_MAP_NOWHERE) {
 542             continue;
 543         }
 544         if (idx >= visLimit) {
 545             continue;
 546         }
 547         accumDst[idx] = srcChars[i];
 548         if (!matchingPair(bidi, i, srcChars[i], dstChars[idx])) {
 549             errDst = TRUE;
 550         }
 551     }
 552     accumDst[visLimit] = 0;
 553     if (U_FAILURE(errorCode)) {
 554         log_err("Error #2 invoking ICU within checkWhatYouCan\n");
 555         return FALSE;
 556     }
 557     if (errMap) {
 558         if (testOK) {
 559             printCaseInfo(bidi, srcChars, dstChars);
 560             testOK = FALSE;
 561         }
 562         log_err("Mismatch between getLogicalMap() and getVisualIndex()\n");
 563         log_err("Map    :");
 564         for (i = 0; i < logLimit; i++) {
 565             log_err(" %d", logMap[i]);
 566         }
 567         fputs("\n", stderr);
 568         log_err("Indexes:");
 569         for (i = 0; i < logLimit; i++) {
 570             log_err(" %d", ubidi_getVisualIndex(bidi, i, &errorCode));
 571         }
 572         fputs("\n", stderr);
 573     }
 574     if (errDst) {
 575         if (testOK) {
 576             printCaseInfo(bidi, srcChars, dstChars);
 577             testOK = FALSE;
 578         }
 579         log_err("Source does not map to Result\n");
 580         log_err("We got: %s", accumDst); fputs("\n", stderr);
 581     }
 582
 583     errMap = errDst = FALSE;
 584     for (i = 0; i < visLimit; i++) {
 585         idx = ubidi_getLogicalIndex(bidi, i, &errorCode);
 586         if (idx != visMap[i]) {
 587             errMap = TRUE;
 588         }
 589         if (idx == UBIDI_MAP_NOWHERE) {
 590             continue;
 591         }
 592         if (idx >= logLimit) {
 593             continue;
 594         }
 595         accumSrc[idx] = dstChars[i];
 596         if (!matchingPair(bidi, idx, srcChars[idx], dstChars[i])) {
 597             errDst = TRUE;
 598         }
 599     }
 600     accumSrc[logLimit] = 0;
 601     if (U_FAILURE(errorCode)) {
 602         log_err("Error #3 invoking ICU within checkWhatYouCan\n");
 603         return FALSE;
 604     }
 605     if (errMap) {
 606         if (testOK) {
 607             printCaseInfo(bidi, srcChars, dstChars);
 608             testOK = FALSE;
 609         }
 610         log_err("Mismatch between getVisualMap() and getLogicalIndex()\n");
 611         log_err("Map    :");
 612         for (i = 0; i < visLimit; i++) {
 613             log_err(" %d", visMap[i]);
 614         }
 615         fputs("\n", stderr);
 616         log_err("Indexes:");
 617         for (i = 0; i < visLimit; i++) {
 618             log_err(" %d", ubidi_getLogicalIndex(bidi, i, &errorCode));
 619         }
 620         fputs("\n", stderr);
 621     }
 622     if (errDst) {
 623         if (testOK) {
 624             printCaseInfo(bidi, srcChars, dstChars);
 625             testOK = FALSE;
 626         }
 627         log_err("Result does not map to Source\n");
 628         log_err("We got: %s", accumSrc);
 629         fputs("\n", stderr);
 630     }
 631     return testOK;
 632 }
 633
 634 static void
 635 testReorder(void) {
 636     static const char* const logicalOrder[] ={
 637             "del(KC)add(K.C.&)",
 638             "del(QDVT) add(BVDL)",
 639             "del(PQ)add(R.S.)T)U.&",
 640             "del(LV)add(L.V.) L.V.&",
 641             "day  0  R  DPDHRVR dayabbr",
 642             "day  1  H  DPHPDHDA dayabbr",
 643             "day  2   L  DPBLENDA dayabbr",
 644             "day  3  J  DPJQVM  dayabbr",
 645             "day  4   I  DPIQNF    dayabbr",
 646             "day  5  M  DPMEG  dayabbr",
 647             "helloDPMEG",
 648             "hello WXYZ"
 649     };
 650     static const char* const visualOrder[]={
 651             "del(CK)add(&.C.K)",
 652             "del(TVDQ) add(LDVB)",
 653             "del(QP)add(S.R.)&.U(T",            /* updated for Unicode 6.3 matching brackets */
 654             "del(VL)add(V.L.) &.V.L",           /* updated for Unicode 6.3 matching brackets */
 655             "day  0  RVRHDPD  R dayabbr",
 656             "day  1  ADHDPHPD  H dayabbr",
 657             "day  2   ADNELBPD  L dayabbr",
 658             "day  3  MVQJPD  J  dayabbr",
 659             "day  4   FNQIPD  I    dayabbr",
 660             "day  5  GEMPD  M  dayabbr",
 661             "helloGEMPD",
 662             "hello ZYXW"
 663     };
 664     static const char* const visualOrder1[]={
 665             ")K.C.&(dda)KC(led",
 666             ")BVDL(dda )QDVT(led",
 667             "T(U.&).R.S(dda)PQ(led",            /* updated for Unicode 6.3 matching brackets */
 668             "L.V.& ).L.V(dda)LV(led",           /* updated for Unicode 6.3 matching brackets */
 669             "rbbayad R  DPDHRVR  0  yad",
 670             "rbbayad H  DPHPDHDA  1  yad",
 671             "rbbayad L  DPBLENDA   2  yad",
 672             "rbbayad  J  DPJQVM  3  yad",
 673             "rbbayad    I  DPIQNF   4  yad",
 674             "rbbayad  M  DPMEG  5  yad",
 675             "DPMEGolleh",
 676             "WXYZ olleh"
 677     };
 678
 679     static const char* const visualOrder2[]={
 680             "@)@K.C.&@(dda)@KC@(led",
 681             "@)@BVDL@(dda )@QDVT@(led",
 682             "R.S.)T)U.&@(dda)@PQ@(led",
 683             "L.V.) L.V.&@(dda)@LV@(led",
 684             "rbbayad @R  DPDHRVR@  0  yad",
 685             "rbbayad @H  DPHPDHDA@  1  yad",
 686             "rbbayad @L  DPBLENDA@   2  yad",
 687             "rbbayad  @J  DPJQVM@  3  yad",
 688             "rbbayad    @I  DPIQNF@   4  yad",
 689             "rbbayad  @M  DPMEG@  5  yad",
 690             "DPMEGolleh",
 691             "WXYZ@ olleh"
 692     };
 693     static const char* const visualOrder3[]={
 694             ")K.C.&(KC)dda(led",
 695             ")BVDL(ddaQDVT) (led",
 696             "R.S.)T)U.&(PQ)dda(led",
 697             "L.V.) L.V.&(LV)dda(led",
 698             "rbbayad DPDHRVR   R  0 yad",
 699             "rbbayad DPHPDHDA   H  1 yad",
 700             "rbbayad DPBLENDA     L 2 yad",
 701             "rbbayad  DPJQVM   J  3 yad",
 702             "rbbayad    DPIQNF     I 4 yad",
 703             "rbbayad  DPMEG   M  5 yad",
 704             "DPMEGolleh",
 705             "WXYZ olleh"
 706     };
 707     static const char* const visualOrder4[]={
 708             "del(add(CK(.C.K)",
 709             "del( (TVDQadd(LDVB)",
 710             "del(add(QP(.U(T(.S.R",
 711             "del(add(VL(.V.L (.V.L",
 712             "day 0  R   RVRHDPD dayabbr",
 713             "day 1  H   ADHDPHPD dayabbr",
 714             "day 2 L     ADNELBPD dayabbr",
 715             "day 3  J   MVQJPD  dayabbr",
 716             "day 4 I     FNQIPD    dayabbr",
 717             "day 5  M   GEMPD  dayabbr",
 718             "helloGEMPD",
 719             "hello ZYXW"
 720     };
 721     char formatChars[MAXLEN];
 722     UErrorCode ec = U_ZERO_ERROR;
 723     UBiDi* bidi = ubidi_open();
 724     int i;
 725
 726     log_verbose("\nEntering TestReorder\n\n");
 727
 728     for(i=0;i<LENGTHOF(logicalOrder);i++){
 729         int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
 730         int32_t destSize = srcSize*2;
 731         UChar src[MAXLEN];
 732         UChar dest[MAXLEN];
 733         char chars[MAXLEN];
 734         log_verbose("Testing L2V #1 for case %d\n", i);
 735         pseudoToU16(srcSize,logicalOrder[i],src);
 736         ec = U_ZERO_ERROR;
 737         ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec);
 738         if(U_FAILURE(ec)){
 739             log_err("ubidi_setPara(tests[%d], paraLevel %d) failed with errorCode %s\n",
 740                     i, UBIDI_DEFAULT_LTR, u_errorName(ec));
 741         }
 742         /* try pre-flighting */
 743         destSize = ubidi_writeReordered(bidi,dest,0,UBIDI_DO_MIRRORING,&ec);
 744         if(ec!=U_BUFFER_OVERFLOW_ERROR){
 745             log_err("Pre-flighting did not give expected error: Expected: U_BUFFER_OVERFLOW_ERROR. Got: %s \n",u_errorName(ec));
 746         }else if(destSize!=srcSize){
 747             log_err("Pre-flighting did not give expected size: Expected: %d. Got: %d \n",srcSize,destSize);
 748         }else{
 749             ec= U_ZERO_ERROR;
 750         }
 751         destSize=ubidi_writeReordered(bidi,dest,destSize+1,UBIDI_DO_MIRRORING,&ec);
 752         u16ToPseudo(destSize,dest,chars);
 753         if(destSize!=srcSize){
 754             log_err("ubidi_writeReordered() destSize and srcSize do not match\n");
 755         }else if(strcmp(visualOrder[i],chars)!=0){
 756             log_err("ubidi_writeReordered() did not give expected results for UBIDI_DO_MIRRORING.\n"
 757                     "Input   : %s\nExpected: %s\nGot     : %s\nLevels  : %s\nAt Index: %d\n",
 758                     logicalOrder[i],visualOrder[i],chars,formatLevels(bidi, formatChars),i);
 759         }
 760         checkWhatYouCan(bidi, logicalOrder[i], chars);
 761     }
 762
 763     for(i=0;i<LENGTHOF(logicalOrder);i++){
 764         int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
 765         int32_t destSize = srcSize*2;
 766         UChar src[MAXLEN];
 767         UChar dest[MAXLEN];
 768         char chars[MAXLEN];
 769         log_verbose("Testing L2V #2 for case %d\n", i);
 770         pseudoToU16(srcSize,logicalOrder[i],src);
 771         ec = U_ZERO_ERROR;
 772         ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec);
 773         if(U_FAILURE(ec)){
 774             log_err("ubidi_setPara(tests[%d], paraLevel %d) failed with errorCode %s\n",
 775                     i, UBIDI_DEFAULT_LTR, u_errorName(ec));
 776         }
 777         /* try pre-flighting */
 778         destSize = ubidi_writeReordered(bidi,dest,0,UBIDI_DO_MIRRORING+UBIDI_OUTPUT_REVERSE,&ec);
 779         if(ec!=U_BUFFER_OVERFLOW_ERROR){
 780             log_err("Pre-flighting did not give expected error: Expected: U_BUFFER_OVERFLOW_ERROR. Got: %s \n",u_errorName(ec));
 781         }else if(destSize!=srcSize){
 782             log_err("Pre-flighting did not give expected size: Expected: %d. Got: %d \n",srcSize,destSize);
 783         }else{
 784             ec= U_ZERO_ERROR;
 785         }
 786         destSize=ubidi_writeReordered(bidi,dest,destSize+1,UBIDI_DO_MIRRORING+UBIDI_OUTPUT_REVERSE,&ec);
 787         u16ToPseudo(destSize,dest,chars);
 788         if(destSize!=srcSize){
 789             log_err("ubidi_writeReordered() destSize and srcSize do not match\n");
 790         }else if(strcmp(visualOrder1[i],chars)!=0){
 791             log_err("ubidi_writeReordered() did not give expected results for UBIDI_DO_MIRRORING+UBIDI_OUTPUT_REVERSE.\n"
 792                     "Input   : %s\nExpected: %s\nGot     : %s\nLevels  : %s\nAt Index: %d\n",
 793                     logicalOrder[i],visualOrder1[i],chars,formatLevels(bidi, formatChars),i);
 794         }
 795     }
 796
 797     for(i=0;i<LENGTHOF(logicalOrder);i++){
 798         int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
 799         int32_t destSize = srcSize*2;
 800         UChar src[MAXLEN];
 801         UChar dest[MAXLEN];
 802         char chars[MAXLEN];
 803         log_verbose("Testing V2L #3 for case %d\n", i);
 804         pseudoToU16(srcSize,logicalOrder[i],src);
 805         ec = U_ZERO_ERROR;
 806         ubidi_setInverse(bidi,TRUE);
 807         ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec);
 808         if(U_FAILURE(ec)){
 809             log_err("ubidi_setPara(tests[%d], paraLevel %d) failed with errorCode %s\n",
 810                     i, UBIDI_DEFAULT_LTR, u_errorName(ec));
 811         }
 812                 /* try pre-flighting */
 813         destSize = ubidi_writeReordered(bidi,dest,0,UBIDI_INSERT_LRM_FOR_NUMERIC+UBIDI_OUTPUT_REVERSE,&ec);
 814         if(ec!=U_BUFFER_OVERFLOW_ERROR){
 815             log_err("Pre-flighting did not give expected error: Expected: U_BUFFER_OVERFLOW_ERROR. Got: %s \n",u_errorName(ec));
 816         }else{
 817             ec= U_ZERO_ERROR;
 818         }
 819         destSize=ubidi_writeReordered(bidi,dest,destSize+1,UBIDI_INSERT_LRM_FOR_NUMERIC+UBIDI_OUTPUT_REVERSE,&ec);
 820         u16ToPseudo(destSize,dest,chars);
 821         if(strcmp(visualOrder2[i],chars)!=0){
 822             log_err("ubidi_writeReordered() did not give expected results for UBIDI_INSERT_LRM_FOR_NUMERIC+UBIDI_OUTPUT_REVERSE.\n"
 823                     "Input   : %s\nExpected: %s\nGot     : %s\nLevels  : %s\nAt Index: %d\n",
 824                     logicalOrder[i],visualOrder2[i],chars,formatLevels(bidi, formatChars),i);
 825         }
 826     }
 827         /* Max Explicit level */
 828     for(i=0;i<LENGTHOF(logicalOrder);i++){
 829         int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
 830         int32_t destSize = srcSize*2;
 831         UChar src[MAXLEN];
 832         UChar dest[MAXLEN];
 833         char chars[MAXLEN];
 834         UBiDiLevel levels[UBIDI_MAX_EXPLICIT_LEVEL]={1,2,3,4,5,6,7,8,9,10};
 835         log_verbose("Testing V2L #4 for case %d\n", i);
 836         pseudoToU16(srcSize,logicalOrder[i],src);
 837         ec = U_ZERO_ERROR;
 838         ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR,levels,&ec);
 839         if(U_FAILURE(ec)){
 840             log_err("ubidi_setPara(tests[%d], paraLevel %d) failed with errorCode %s\n",
 841                     i, UBIDI_MAX_EXPLICIT_LEVEL, u_errorName(ec));
 842         }
 843                 /* try pre-flighting */
 844         destSize = ubidi_writeReordered(bidi,dest,0,UBIDI_OUTPUT_REVERSE,&ec);
 845         if(ec!=U_BUFFER_OVERFLOW_ERROR){
 846             log_err("Pre-flighting did not give expected error: Expected: U_BUFFER_OVERFLOW_ERROR. Got: %s \n",u_errorName(ec));
 847         }else if(destSize!=srcSize){
 848             log_err("Pre-flighting did not give expected size: Expected: %d. Got: %d \n",srcSize,destSize);
 849         }else{
 850             ec = U_ZERO_ERROR;
 851         }
 852         destSize=ubidi_writeReordered(bidi,dest,destSize+1,UBIDI_OUTPUT_REVERSE,&ec);
 853         u16ToPseudo(destSize,dest,chars);
 854         if(destSize!=srcSize){
 855             log_err("ubidi_writeReordered() destSize and srcSize do not match. Dest Size = %d Source Size = %d\n",destSize,srcSize );
 856         }else if(strcmp(visualOrder3[i],chars)!=0){
 857             log_err("ubidi_writeReordered() did not give expected results for UBIDI_OUTPUT_REVERSE.\n"
 858                     "Input   : %s\nExpected: %s\nGot     : %s\nLevels  : %s\nAt Index: %d\n",
 859                     logicalOrder[i],visualOrder3[i],chars,formatLevels(bidi, formatChars),i);
 860         }
 861     }
 862     for(i=0;i<LENGTHOF(logicalOrder);i++){
 863         int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
 864         int32_t destSize = srcSize*2;
 865         UChar src[MAXLEN];
 866         UChar dest[MAXLEN];
 867         char chars[MAXLEN];
 868         UBiDiLevel levels[UBIDI_MAX_EXPLICIT_LEVEL]={1,2,3,4,5,6,7,8,9,10};
 869         log_verbose("Testing V2L #5 for case %d\n", i);
 870         pseudoToU16(srcSize,logicalOrder[i],src);
 871         ec = U_ZERO_ERROR;
 872         ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR,levels,&ec);
 873         if(U_FAILURE(ec)){
 874             log_err("ubidi_setPara(tests[%d], paraLevel %d) failed with errorCode %s\n",
 875                     i, UBIDI_MAX_EXPLICIT_LEVEL, u_errorName(ec));
 876         }
 877         /* try pre-flighting */
 878         destSize = ubidi_writeReordered(bidi,dest,0,UBIDI_DO_MIRRORING+UBIDI_REMOVE_BIDI_CONTROLS,&ec);
 879         if(ec!=U_BUFFER_OVERFLOW_ERROR){
 880             log_err("Pre-flighting did not give expected error: Expected: U_BUFFER_OVERFLOW_ERROR. Got: %s \n",u_errorName(ec));
 881         }else{
 882             ec= U_ZERO_ERROR;
 883         }
 884         destSize=ubidi_writeReordered(bidi,dest,destSize+1,UBIDI_DO_MIRRORING+UBIDI_REMOVE_BIDI_CONTROLS,&ec);
 885         u16ToPseudo(destSize,dest,chars);
 886         if(strcmp(visualOrder4[i],chars)!=0){
 887             log_err("ubidi_writeReordered() did not give expected results for UBIDI_DO_MIRRORING+UBIDI_REMOVE_BIDI_CONTROLS.\n"
 888                     "Input   : %s\nExpected: %s\nGot     : %s\nLevels  : %s\nAt Index: %d\n",
 889                     logicalOrder[i],visualOrder4[i],chars,formatLevels(bidi, formatChars),i);
 890         }
 891     }
 892     ubidi_close(bidi);
 893
 894     log_verbose("\nExiting TestReorder\n\n");
 895 }
 896
 897 static void
 898 testReorderArabicMathSymbols(void) {
 899     static const UChar logicalOrder[][MAXLEN]={
 900         /* Arabic mathematical Symbols 0x1EE00 - 0x1EE1B */
 901         {0xD83B, 0xDE00, 0xD83B, 0xDE01, 0xD83B, 0xDE02, 0xD83B, 0xDE03, 0x20,
 902         0xD83B, 0xDE24, 0xD83B, 0xDE05, 0xD83B, 0xDE06, 0x20,
 903         0xD83B, 0xDE07, 0xD83B, 0xDE08, 0xD83B, 0xDE09, 0x20,
 904         0xD83B, 0xDE0A, 0xD83B, 0xDE0B, 0xD83B, 0xDE0C, 0xD83B, 0xDE0D, 0x20,
 905         0xD83B, 0xDE0E, 0xD83B, 0xDE0F, 0xD83B, 0xDE10, 0xD83B, 0xDE11, 0x20,
 906         0xD83B, 0xDE12, 0xD83B, 0xDE13, 0xD83B, 0xDE14, 0xD83B, 0xDE15, 0x20,
 907         0xD83B, 0xDE16, 0xD83B, 0xDE17, 0xD83B, 0xDE18, 0x20,
 908         0xD83B, 0xDE19, 0xD83B, 0xDE1A, 0xD83B, 0xDE1B},
 909         /* Arabic mathematical Symbols - Looped Symbols, 0x1EE80 - 0x1EE9B */
 910         {0xD83B, 0xDE80, 0xD83B, 0xDE81, 0xD83B, 0xDE82, 0xD83B, 0xDE83, 0x20,
 911         0xD83B, 0xDE84, 0xD83B, 0xDE85, 0xD83B, 0xDE86, 0x20,
 912         0xD83B, 0xDE87, 0xD83B, 0xDE88, 0xD83B, 0xDE89, 0x20,
 913         0xD83B, 0xDE8B, 0xD83B, 0xDE8C, 0xD83B, 0xDE8D, 0x20,
 914         0xD83B, 0xDE8E, 0xD83B, 0xDE8F, 0xD83B, 0xDE90, 0xD83B, 0xDE91, 0x20,
 915         0xD83B, 0xDE92, 0xD83B, 0xDE93, 0xD83B, 0xDE94, 0xD83B, 0xDE95, 0x20,
 916         0xD83B, 0xDE96, 0xD83B, 0xDE97, 0xD83B, 0xDE98, 0x20,
 917         0xD83B, 0xDE99, 0xD83B, 0xDE9A, 0xD83B, 0xDE9B},
 918         /* Arabic mathematical Symbols - Double-struck Symbols, 0x1EEA1 - 0x1EEBB */
 919         {0xD83B, 0xDEA1, 0xD83B, 0xDEA2, 0xD83B, 0xDEA3, 0x20,
 920         0xD83B, 0xDEA5, 0xD83B, 0xDEA6, 0x20,
 921         0xD83B, 0xDEA7, 0xD83B, 0xDEA8, 0xD83B, 0xDEA9, 0x20,
 922         0xD83B, 0xDEAB, 0xD83B, 0xDEAC, 0xD83B, 0xDEAD, 0x20,
 923         0xD83B, 0xDEAE, 0xD83B, 0xDEAF, 0xD83B, 0xDEB0, 0xD83B, 0xDEB1, 0x20,
 924         0xD83B, 0xDEB2, 0xD83B, 0xDEB3, 0xD83B, 0xDEB4, 0xD83B, 0xDEB5, 0x20,
 925         0xD83B, 0xDEB6, 0xD83B, 0xDEB7, 0xD83B, 0xDEB8, 0x20,
 926         0xD83B, 0xDEB9, 0xD83B, 0xDEBA, 0xD83B, 0xDEBB},
 927         /* Arabic mathematical Symbols - Initial Symbols, 0x1EE21 - 0x1EE3B */
 928         {0xD83B, 0xDE21, 0xD83B, 0xDE22, 0x20,
 929         0xD83B, 0xDE27, 0xD83B, 0xDE29, 0x20,
 930         0xD83B, 0xDE2A, 0xD83B, 0xDE2B, 0xD83B, 0xDE2C, 0xD83B, 0xDE2D, 0x20,
 931         0xD83B, 0xDE2E, 0xD83B, 0xDE2F, 0xD83B, 0xDE30, 0xD83B, 0xDE31, 0x20,
 932         0xD83B, 0xDE32, 0xD83B, 0xDE34, 0xD83B, 0xDE35, 0x20,
 933         0xD83B, 0xDE36, 0xD83B, 0xDE37, 0x20,
 934         0xD83B, 0xDE39, 0xD83B, 0xDE3B},
 935         /* Arabic mathematical Symbols - Tailed Symbols */
 936         {0xD83B, 0xDE42, 0xD83B, 0xDE47, 0xD83B, 0xDE49, 0xD83B, 0xDE4B, 0x20,
 937         0xD83B, 0xDE4D, 0xD83B, 0xDE4E, 0xD83B, 0xDE4F, 0x20,
 938         0xD83B, 0xDE51, 0xD83B, 0xDE52, 0xD83B, 0xDE54, 0xD83B, 0xDE57, 0x20,
 939         0xD83B, 0xDE59, 0xD83B, 0xDE5B, 0xD83B, 0xDE5D, 0xD83B, 0xDE5F}
 940     };
 941     static const UChar visualOrder[][MAXLEN]={
 942         /* Arabic mathematical Symbols 0x1EE00 - 0x1EE1B */
 943         {0xD83B, 0xDE1B, 0xD83B, 0xDE1A, 0xD83B, 0xDE19, 0x20,
 944         0xD83B, 0xDE18, 0xD83B, 0xDE17, 0xD83B, 0xDE16, 0x20,
 945         0xD83B, 0xDE15, 0xD83B, 0xDE14, 0xD83B, 0xDE13, 0xD83B, 0xDE12, 0x20,
 946         0xD83B, 0xDE11, 0xD83B, 0xDE10, 0xD83B, 0xDE0F, 0xD83B, 0xDE0E, 0x20,
 947         0xD83B, 0xDE0D, 0xD83B, 0xDE0C, 0xD83B, 0xDE0B, 0xD83B, 0xDE0A, 0x20,
 948         0xD83B, 0xDE09, 0xD83B, 0xDE08, 0xD83B, 0xDE07, 0x20,
 949         0xD83B, 0xDE06, 0xD83B, 0xDE05, 0xD83B, 0xDE24, 0x20,
 950         0xD83B, 0xDE03, 0xD83B, 0xDE02, 0xD83B, 0xDE01, 0xD83B, 0xDE00},
 951         /* Arabic mathematical Symbols - Looped Symbols, 0x1EE80 - 0x1EE9B */
 952         {0xD83B, 0xDE9B, 0xD83B, 0xDE9A, 0xD83B, 0xDE99, 0x20,
 953         0xD83B, 0xDE98, 0xD83B, 0xDE97, 0xD83B, 0xDE96, 0x20,
 954         0xD83B, 0xDE95, 0xD83B, 0xDE94, 0xD83B, 0xDE93, 0xD83B, 0xDE92, 0x20,
 955         0xD83B, 0xDE91, 0xD83B, 0xDE90, 0xD83B, 0xDE8F, 0xD83B, 0xDE8E, 0x20,
 956         0xD83B, 0xDE8D, 0xD83B, 0xDE8C, 0xD83B, 0xDE8B, 0x20,
 957         0xD83B, 0xDE89, 0xD83B, 0xDE88, 0xD83B, 0xDE87, 0x20,
 958         0xD83B, 0xDE86, 0xD83B, 0xDE85, 0xD83B, 0xDE84, 0x20,
 959         0xD83B, 0xDE83, 0xD83B, 0xDE82, 0xD83B, 0xDE81, 0xD83B, 0xDE80},
 960         /* Arabic mathematical Symbols - Double-struck Symbols, 0x1EEA1 - 0x1EEBB */
 961         {0xD83B, 0xDEBB, 0xD83B, 0xDEBA, 0xD83B, 0xDEB9, 0x20,
 962         0xD83B, 0xDEB8, 0xD83B, 0xDEB7, 0xD83B, 0xDEB6, 0x20,
 963         0xD83B, 0xDEB5, 0xD83B, 0xDEB4, 0xD83B, 0xDEB3, 0xD83B, 0xDEB2, 0x20,
 964         0xD83B, 0xDEB1, 0xD83B, 0xDEB0, 0xD83B, 0xDEAF, 0xD83B, 0xDEAE, 0x20,
 965         0xD83B, 0xDEAD, 0xD83B, 0xDEAC, 0xD83B, 0xDEAB, 0x20,
 966         0xD83B, 0xDEA9, 0xD83B, 0xDEA8, 0xD83B, 0xDEA7, 0x20,
 967         0xD83B, 0xDEA6, 0xD83B, 0xDEA5, 0x20,
 968         0xD83B, 0xDEA3, 0xD83B, 0xDEA2, 0xD83B, 0xDEA1},
 969         /* Arabic mathematical Symbols - Initial Symbols, 0x1EE21 - 0x1EE3B */
 970         {0xD83B, 0xDE3B, 0xD83B, 0xDE39, 0x20,
 971         0xD83B, 0xDE37, 0xD83B, 0xDE36, 0x20,
 972         0xD83B, 0xDE35, 0xD83B, 0xDE34, 0xD83B, 0xDE32, 0x20,
 973         0xD83B, 0xDE31, 0xD83B, 0xDE30, 0xD83B, 0xDE2F, 0xD83B, 0xDE2E, 0x20,
 974         0xD83B, 0xDE2D, 0xD83B, 0xDE2C, 0xD83B, 0xDE2B, 0xD83B, 0xDE2A, 0x20,
 975         0xD83B, 0xDE29, 0xD83B, 0xDE27, 0x20,
 976         0xD83B, 0xDE22, 0xD83B, 0xDE21},
 977         /* Arabic mathematical Symbols - Tailed Symbols */
 978         {0xD83B, 0xDE5F, 0xD83B, 0xDE5D, 0xD83B, 0xDE5B, 0xD83B, 0xDE59, 0x20,
 979         0xD83B, 0xDE57, 0xD83B, 0xDE54, 0xD83B, 0xDE52, 0xD83B, 0xDE51, 0x20,
 980         0xD83B, 0xDE4F, 0xD83B, 0xDE4E, 0xD83B, 0xDE4D, 0x20,
 981         0xD83B, 0xDE4B, 0xD83B, 0xDE49, 0xD83B, 0xDE47, 0xD83B, 0xDE42}
 982     };
 983     char formatChars[MAXLEN];
 984     UErrorCode ec = U_ZERO_ERROR;
 985     UBiDi* bidi = ubidi_open();
 986     int i;
 987
 988     log_verbose("\nEntering TestReorderArabicMathSymbols\n\n");
 989
 990     for(i=0;i<LENGTHOF(logicalOrder);i++){
 991         int32_t srcSize = u_strlen(logicalOrder[i]);
 992         int32_t destSize = srcSize*2;
 993         UChar dest[MAXLEN];
 994         log_verbose("Testing L2V #1 for case %d\n", i);
 995         ec = U_ZERO_ERROR;
 996         ubidi_setPara(bidi,logicalOrder[i],srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec);
 997         if(U_FAILURE(ec)){
 998             log_err("ubidi_setPara(tests[%d], paraLevel %d) failed with errorCode %s\n",
 999                     i, UBIDI_DEFAULT_LTR, u_errorName(ec));
1000         }
1001         /* try pre-flighting */
1002         destSize = ubidi_writeReordered(bidi,dest,0,UBIDI_DO_MIRRORING,&ec);
1003         if(ec!=U_BUFFER_OVERFLOW_ERROR){
1004             log_err("Pre-flighting did not give expected error: Expected: U_BUFFER_OVERFLOW_ERROR. Got: %s \n",u_errorName(ec));
1005         }else if(destSize!=srcSize){
1006             log_err("Pre-flighting did not give expected size: Expected: %d. Got: %d \n",srcSize,destSize);
1007         }else{
1008             ec= U_ZERO_ERROR;
1009         }
1010         destSize=ubidi_writeReordered(bidi,dest,destSize+1,UBIDI_DO_MIRRORING,&ec);
1011         if(destSize!=srcSize){
1012             log_err("ubidi_writeReordered() destSize and srcSize do not match\n");
1013         }else if(memcmp(dest, visualOrder[i], destSize*U_SIZEOF_UCHAR)!=0){
1014             log_err("ubidi_writeReordered() did not give expected results for UBIDI_DO_MIRRORING.\n"
1015                     "Input   : %s\nExpected: %s\nGot     : %s\nLevels  : %s\nAt Index: %d\n",
1016                     logicalOrder[i],visualOrder[i],dest,formatLevels(bidi, formatChars),i);
1017         }
1018     }
1019
1020     ubidi_close(bidi);
1021
1022     log_verbose("\nExiting TestReorderArabicMathSymbols\n\n");
1023 }
1024
1025 static void
1026 doTest(UBiDi *pBiDi, int testNumber, const BiDiTestData *test, int32_t lineStart, UBool countRunsFirst) {
1027     const uint8_t *dirProps=test->text+lineStart;
1028     const UBiDiLevel *levels=test->levels;
1029     const uint8_t *visualMap=test->visualMap;
1030     int32_t i, len=ubidi_getLength(pBiDi), logicalIndex, runCount = 0;
1031     UErrorCode errorCode=U_ZERO_ERROR;
1032     UBiDiLevel level, level2;
1033
1034     if (countRunsFirst) {
1035         log_verbose("Calling ubidi_countRuns() first.\n");
1036
1037         runCount = ubidi_countRuns(pBiDi, &errorCode);
1038
1039         if(U_FAILURE(errorCode)) {
1040             log_err("ubidi_countRuns(tests[%d]): error %s\n", testNumber, myErrorName(errorCode));
1041             return;
1042         }
1043     } else {
1044         log_verbose("Calling ubidi_getLogicalMap() first.\n");
1045     }
1046
1047     _testReordering(pBiDi, testNumber);
1048
1049     for(i=0; i<len; ++i) {
1050         log_verbose("%3d %3d %.*s%-3s @%d\n",
1051                 i, ubidi_getLevelAt(pBiDi, i), ubidi_getLevelAt(pBiDi, i), levelString,
1052                 dirPropNames[dirProps[i]],
1053                 ubidi_getVisualIndex(pBiDi, i, &errorCode));
1054     }
1055
1056     log_verbose("\n-----levels:");
1057     for(i=0; i<len; ++i) {
1058         if(i>0) {
1059             log_verbose(",");
1060         }
1061         log_verbose(" %d", ubidi_getLevelAt(pBiDi, i));
1062     }
1063
1064     log_verbose("\n--reordered:");
1065     for(i=0; i<len; ++i) {
1066         if(i>0) {
1067             log_verbose(",");
1068         }
1069         log_verbose(" %d", ubidi_getVisualIndex(pBiDi, i, &errorCode));
1070     }
1071     log_verbose("\n");
1072
1073     if(test->direction!=ubidi_getDirection(pBiDi)) {
1074         log_err("ubidi_getDirection(tests[%d]): wrong direction %d\n", testNumber, ubidi_getDirection(pBiDi));
1075     }
1076
1077     if(test->resultLevel!=ubidi_getParaLevel(pBiDi)) {
1078         log_err("ubidi_getParaLevel(tests[%d]): wrong paragraph level %d\n", testNumber, ubidi_getParaLevel(pBiDi));
1079     }
1080
1081     for(i=0; i<len; ++i) {
1082         if(levels[i]!=ubidi_getLevelAt(pBiDi, i)) {
1083             log_err("ubidi_getLevelAt(tests[%d], %d): wrong level %d, expected %d\n", testNumber, i, ubidi_getLevelAt(pBiDi, i), levels[i]);
1084             return;
1085         }
1086     }
1087
1088     for(i=0; i<len; ++i) {
1089         logicalIndex=ubidi_getVisualIndex(pBiDi, i, &errorCode);
1090         if(U_FAILURE(errorCode)) {
1091             log_err("ubidi_getVisualIndex(tests[%d], %d): error %s\n", testNumber, i, myErrorName(errorCode));
1092             return;
1093         }
1094         if(visualMap[i]!=logicalIndex) {
1095             log_err("ubidi_getVisualIndex(tests[%d], %d): wrong index %d\n", testNumber, i, logicalIndex);
1096             return;
1097         }
1098     }
1099
1100     if (! countRunsFirst) {
1101         runCount=ubidi_countRuns(pBiDi, &errorCode);
1102         if(U_FAILURE(errorCode)) {
1103             log_err("ubidi_countRuns(tests[%d]): error %s\n", testNumber, myErrorName(errorCode));
1104             return;
1105         }
1106     }
1107
1108     for(logicalIndex=0; logicalIndex<len;) {
1109         level=ubidi_getLevelAt(pBiDi, logicalIndex);
1110         ubidi_getLogicalRun(pBiDi, logicalIndex, &logicalIndex, &level2);
1111         if(level!=level2) {
1112             log_err("ubidi_getLogicalRun(tests[%d], run ending at index %d): "
1113                     "wrong level %d instead of %d\n",
1114                     testNumber, logicalIndex, level, level2);
1115         }
1116         if(--runCount<0) {
1117             log_err("\nubidi_getLogicalRun(tests[%d]): wrong number of runs "
1118                     "compared to %d=ubidi_countRuns()\n",
1119                     testNumber, ubidi_countRuns(pBiDi, &errorCode));
1120             return;
1121         }
1122     }
1123     if(runCount!=0) {
1124         log_err("\nubidi_getLogicalRun(tests[%d]): wrong number of runs "
1125                 "compared to %d=ubidi_getRunCount()\n",
1126                 testNumber, ubidi_countRuns(pBiDi, &errorCode));
1127         return;
1128     }
1129
1130     log_verbose("\n\n");
1131 }
1132
1133 static void
1134 _testReordering(UBiDi *pBiDi, int testNumber) {
1135     int32_t
1136         logicalMap1[MAXLEN], logicalMap2[MAXLEN], logicalMap3[MAXLEN],
1137         visualMap1[MAXLEN], visualMap2[MAXLEN], visualMap3[MAXLEN], visualMap4[MAXLEN];
1138     UErrorCode errorCode=U_ZERO_ERROR;
1139     const UBiDiLevel *levels;
1140     int32_t i, length=ubidi_getLength(pBiDi),
1141                destLength=ubidi_getResultLength(pBiDi);
1142     int32_t runCount, visualIndex, logicalStart, runLength;
1143     UBool odd;
1144
1145     if(length<=0) {
1146         return;
1147     }
1148
1149     /* get the logical and visual maps from the object */
1150     ubidi_getLogicalMap(pBiDi, logicalMap1, &errorCode);
1151     if(U_FAILURE(errorCode)) {
1152         log_err("ubidi_getLogicalMap(tests[%d]): error %s\n", testNumber, myErrorName(errorCode));
1153         return;
1154     }
1155
1156     ubidi_getVisualMap(pBiDi, visualMap1, &errorCode);
1157     if(U_FAILURE(errorCode)) {
1158         log_err("ubidi_getVisualMap(tests[%d]): error %s\n", testNumber, myErrorName(errorCode));
1159         return;
1160     }
1161
1162     /* invert them both */
1163     ubidi_invertMap(logicalMap1, visualMap2, length);
1164     ubidi_invertMap(visualMap1, logicalMap2, destLength);
1165
1166     /* get them from the levels array, too */
1167     levels=ubidi_getLevels(pBiDi, &errorCode);
1168
1169     if(U_FAILURE(errorCode)) {
1170         log_err("ubidi_getLevels(tests[%d]): error %s\n", testNumber, myErrorName(errorCode));
1171         return;
1172     }
1173
1174     ubidi_reorderLogical(levels, length, logicalMap3);
1175     ubidi_reorderVisual(levels, length, visualMap3);
1176
1177     /* get the visual map from the runs, too */
1178     runCount=ubidi_countRuns(pBiDi, &errorCode);
1179     if(U_FAILURE(errorCode)) {
1180         log_err("ubidi_countRuns(tests[%d]): error %s\n", testNumber, myErrorName(errorCode));
1181         return;
1182     }
1183     log_verbose("\n----%2d runs:", runCount);
1184     visualIndex=0;
1185     for(i=0; i<runCount; ++i) {
1186         odd=(UBool)ubidi_getVisualRun(pBiDi, i, &logicalStart, &runLength);
1187         log_verbose(" (%c @%d[%d])", odd ? 'R' : 'L', logicalStart, runLength);
1188         if(UBIDI_LTR==odd) {
1189             do { /* LTR */
1190                 visualMap4[visualIndex++]=logicalStart++;
1191             } while(--runLength>0);
1192         } else {
1193             logicalStart+=runLength;   /* logicalLimit */
1194             do { /* RTL */
1195                 visualMap4[visualIndex++]=--logicalStart;
1196             } while(--runLength>0);
1197         }
1198     }
1199     log_verbose("\n");
1200
1201     /* print all the maps */
1202     log_verbose("logical maps:\n");
1203     for(i=0; i<length; ++i) {
1204         log_verbose("%4d", logicalMap1[i]);
1205     }
1206     log_verbose("\n");
1207     for(i=0; i<length; ++i) {
1208         log_verbose("%4d", logicalMap2[i]);
1209     }
1210     log_verbose("\n");
1211     for(i=0; i<length; ++i) {
1212         log_verbose("%4d", logicalMap3[i]);
1213     }
1214
1215     log_verbose("\nvisual maps:\n");
1216     for(i=0; i<destLength; ++i) {
1217         log_verbose("%4d", visualMap1[i]);
1218     }
1219     log_verbose("\n");
1220     for(i=0; i<destLength; ++i) {
1221         log_verbose("%4d", visualMap2[i]);
1222     }
1223     log_verbose("\n");
1224     for(i=0; i<length; ++i) {
1225         log_verbose("%4d", visualMap3[i]);
1226     }
1227     log_verbose("\n");
1228     for(i=0; i<length; ++i) {
1229         log_verbose("%4d", visualMap4[i]);
1230     }
1231     log_verbose("\n");
1232
1233     /* check that the indexes are the same between these and ubidi_getLogical/VisualIndex() */
1234     for(i=0; i<length; ++i) {
1235         if(logicalMap1[i]!=logicalMap2[i]) {
1236             log_err("bidi reordering error in tests[%d]: logicalMap1[i]!=logicalMap2[i] at i=%d\n", testNumber, i);
1237             break;
1238         }
1239         if(logicalMap1[i]!=logicalMap3[i]) {
1240             log_err("bidi reordering error in tests[%d]: logicalMap1[i]!=logicalMap3[i] at i=%d\n", testNumber, i);
1241             break;
1242         }
1243
1244         if(visualMap1[i]!=visualMap2[i]) {
1245             log_err("bidi reordering error in tests[%d]: visualMap1[i]!=visualMap2[i] at i=%d\n", testNumber, i);
1246             break;
1247         }
1248         if(visualMap1[i]!=visualMap3[i]) {
1249             log_err("bidi reordering error in tests[%d]: visualMap1[i]!=visualMap3[i] at i=%d\n", testNumber, i);
1250             break;
1251         }
1252         if(visualMap1[i]!=visualMap4[i]) {
1253             log_err("bidi reordering error in tests[%d]: visualMap1[i]!=visualMap4[i] at i=%d\n", testNumber, i);
1254             break;
1255         }
1256
1257         if(logicalMap1[i]!=ubidi_getVisualIndex(pBiDi, i, &errorCode)) {
1258             log_err("bidi reordering error in tests[%d]: logicalMap1[i]!=ubidi_getVisualIndex(i) at i=%d\n", testNumber, i);
1259             break;
1260         }
1261         if(U_FAILURE(errorCode)) {
1262             log_err("ubidi_getVisualIndex(tests[%d], %d): error %s\n", testNumber, i, myErrorName(errorCode));
1263             break;
1264         }
1265         if(visualMap1[i]!=ubidi_getLogicalIndex(pBiDi, i, &errorCode)) {
1266             log_err("bidi reordering error in tests[%d]: visualMap1[i]!=ubidi_getLogicalIndex(i) at i=%d\n", testNumber, i);
1267             break;
1268         }
1269         if(U_FAILURE(errorCode)) {
1270             log_err("ubidi_getLogicalIndex(tests[%d], %d): error %s\n", testNumber, i, myErrorName(errorCode));
1271             break;
1272         }
1273     }
1274 }
1275
1276 #define RETURN_IF_BAD_ERRCODE(x)    \
1277     if (U_FAILURE(errorCode)) {      \
1278         log_err("\nbad errorCode %d at %s\n", errorCode, (x));  \
1279         return;     \
1280     }               \
1281
1282 #define STRING_TEST_CASE(s) { (s), LENGTHOF(s) }
1283
1284 static void testGetBaseDirection(void) {
1285     UBiDiDirection dir;
1286     int i;
1287
1288 /* Test Data */
1289     static const UChar
1290 /*Mixed Start with L*/
1291     stringMixedEnglishFirst[]={ 0x61, 0x627, 0x32, 0x6f3, 0x61, 0x34, 0 },
1292 /*Mixed Start with AL*/
1293     stringMixedArabicFirst[]={ 0x661, 0x627, 0x662, 0x6f3, 0x61, 0x664, 0 },
1294 /*Mixed Start with R*/
1295     stringMixedHebrewFirst[]={ 0x05EA, 0x627, 0x662, 0x6f3, 0x61, 0x664, 0 },
1296 /*All AL (Arabic. Persian)*/
1297     stringPersian[]={0x0698, 0x067E, 0x0686, 0x06AF, 0},
1298 /*All R (Hebrew etc.)*/
1299     stringHebrew[]={0x0590, 0x05D5, 0x05EA, 0x05F1, 0},
1300 /*All L (English)*/
1301     stringEnglish[]={0x71, 0x61, 0x66, 0},
1302 /*Mixed Start with weak AL an then L*/
1303     stringStartWeakAL[]={ 0x0663, 0x71, 0x61, 0x66, 0},
1304 /*Mixed Start with weak L and then AL*/
1305     stringStartWeakL[]={0x31, 0x0698, 0x067E, 0x0686, 0x06AF, 0},
1306 /*Empty*/
1307     stringEmpty[]={0},
1308 /*Surrogate Char.*/
1309     stringSurrogateChar[]={0xD800, 0xDC00, 0},
1310 /*Invalid UChar*/
1311     stringInvalidUchar[]={-1},
1312 /*All weak L (English Digits)*/
1313     stringAllEnglishDigits[]={0x31, 0x32, 0x33, 0},
1314 /*All weak AL (Arabic Digits)*/
1315     stringAllArabicDigits[]={0x0663, 0x0664, 0x0665, 0},
1316 /*First L (English) others are R (Hebrew etc.) */
1317     stringFirstL[] = {0x71, 0x0590, 0x05D5, 0x05EA, 0x05F1, 0},
1318 /*Last R (Hebrew etc.) others are weak L (English Digits)*/
1319     stringLastR[] = {0x31, 0x32, 0x33, 0x05F1, 0};
1320
1321     static const struct {
1322         const UChar *s;
1323         int32_t length;
1324     } testCases[]={
1325         STRING_TEST_CASE(stringMixedEnglishFirst),
1326         STRING_TEST_CASE(stringMixedArabicFirst),
1327         STRING_TEST_CASE(stringMixedHebrewFirst),
1328         STRING_TEST_CASE(stringPersian),
1329         STRING_TEST_CASE(stringHebrew),
1330         STRING_TEST_CASE(stringEnglish),
1331         STRING_TEST_CASE(stringStartWeakAL),
1332         STRING_TEST_CASE(stringStartWeakL),
1333         STRING_TEST_CASE(stringEmpty),
1334         STRING_TEST_CASE(stringSurrogateChar),
1335         STRING_TEST_CASE(stringInvalidUchar),
1336         STRING_TEST_CASE(stringAllEnglishDigits),
1337         STRING_TEST_CASE(stringAllArabicDigits),
1338         STRING_TEST_CASE(stringFirstL),
1339         STRING_TEST_CASE(stringLastR),
1340     };
1341
1342 /* Expected results */
1343     static const UBiDiDirection expectedDir[] ={
1344         UBIDI_LTR, UBIDI_RTL, UBIDI_RTL,
1345         UBIDI_RTL, UBIDI_RTL, UBIDI_LTR,
1346         UBIDI_LTR, UBIDI_RTL, UBIDI_NEUTRAL,
1347         UBIDI_LTR, UBIDI_NEUTRAL, UBIDI_NEUTRAL,
1348         UBIDI_NEUTRAL, UBIDI_LTR, UBIDI_RTL
1349     };
1350
1351     log_verbose("testGetBaseDirection() with %u test cases ---\n",
1352     LENGTHOF(testCases));
1353 /* Run Tests */
1354      for(i=0; i<LENGTHOF(testCases); ++i) {
1355         dir = ubidi_getBaseDirection(testCases[i].s, testCases[i].length );
1356         log_verbose("Testing case %d\tReceived dir %d\n", i, dir);
1357         if (dir != expectedDir[i])
1358             log_err("\nFailed getBaseDirection case %d Expected  %d \tReceived %d\n",
1359             i, expectedDir[i], dir);
1360     }
1361
1362 /* Misc. tests */
1363 /* NULL string */
1364     dir = ubidi_getBaseDirection(NULL, 3);
1365     if (dir != UBIDI_NEUTRAL )
1366         log_err("\nFailed getBaseDirection for NULL string " ,
1367         "\nExpected  %d \nReceived %d", UBIDI_NEUTRAL, dir);
1368 /*All L- English string and length=-3 */
1369     dir = ubidi_getBaseDirection( stringEnglish, -3);
1370     if (dir != UBIDI_NEUTRAL )
1371         log_err("\nFailed getBaseDirection for string w length= -3 ",
1372         "\nExpected  %d \nReceived %d", UBIDI_NEUTRAL, dir);
1373 /*All L- English string and length=-1 */
1374     dir = ubidi_getBaseDirection( stringEnglish, -1);
1375     if (dir != UBIDI_LTR )
1376         log_err("\nFailed getBaseDirection for English string w length= -1 ",
1377         "\nExpected  %d \nReceived %d", UBIDI_LTR, dir);
1378 /*All AL- Persian string and length=-1 */
1379     dir = ubidi_getBaseDirection( stringPersian, -1);
1380     if (dir != UBIDI_RTL )
1381         log_err("\nFailed getBaseDirection for Persian string w length= -1 ",
1382         "\nExpected  %d \nReceived %d", UBIDI_RTL, dir);
1383 /*All R- Hebrew string and length=-1 */
1384     dir = ubidi_getBaseDirection( stringHebrew, -1);
1385     if (dir != UBIDI_RTL )
1386         log_err("\nFailed getBaseDirection for Hebrew string w length= -1 ",
1387         "\nExpected  %d \nReceived %d", UBIDI_RTL, dir);
1388 /*All weak L- English digits string and length=-1 */
1389     dir = ubidi_getBaseDirection(stringAllEnglishDigits, -1);
1390     if (dir != UBIDI_NEUTRAL )
1391         log_err("\nFailed getBaseDirection for English digits string w length= -1 ",
1392         "\nExpected  %d \nReceived %d", UBIDI_NEUTRAL, dir);
1393 /*All weak AL- Arabic digits string and length=-1 */
1394     dir = ubidi_getBaseDirection(stringAllArabicDigits, -1);
1395     if (dir != UBIDI_NEUTRAL )
1396         log_err("\nFailed getBaseDirection for Arabic string w length= -1 ",
1397         "\nExpected  %d \nReceived %d", UBIDI_NEUTRAL, dir);
1398
1399 }
1400
1401
1402 static void doMisc(void) {
1403 /* Miscellaneous tests to exercize less popular code paths */
1404     UBiDi *bidi, *bidiLine;
1405     UChar src[MAXLEN], dest[MAXLEN];
1406     int32_t srcLen, destLen, runCount, i;
1407     UBiDiLevel level;
1408     UBiDiDirection dir;
1409     int32_t map[MAXLEN];
1410     UErrorCode errorCode=U_ZERO_ERROR;
1411     static const int32_t srcMap[6] = {0,1,-1,5,4};
1412     static const int32_t dstMap[6] = {0,1,-1,-1,4,3};
1413
1414     bidi = ubidi_openSized(120, 66, &errorCode);
1415     if (bidi == NULL) {
1416         log_err("Error with openSized(120, 66)\n");
1417         return;
1418     }
1419     bidiLine = ubidi_open();
1420     if (bidi == NULL) {
1421         log_err("Error with open()\n");
1422         return;
1423     }
1424
1425     destLen = ubidi_writeReverse(src, 0, dest, MAXLEN, 0, &errorCode);
1426     if (destLen != 0) {
1427         log_err("\nwriteReverse should return zero length, ",
1428                 "returned %d instead\n", destLen);
1429     }
1430     RETURN_IF_BAD_ERRCODE("#1#");
1431
1432     ubidi_setPara(bidi, src, 0, UBIDI_LTR, NULL, &errorCode);
1433     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1434     if (destLen != 0) {
1435         log_err("\nwriteReordered should return zero length, ",
1436                 "returned %d instead\n", destLen);
1437     }
1438     RETURN_IF_BAD_ERRCODE("#2#");
1439
1440     srcLen = u_unescape("abc       ", src, MAXLEN);
1441     ubidi_setPara(bidi, src, srcLen, UBIDI_RTL, NULL, &errorCode);
1442     ubidi_setLine(bidi, 0, 6, bidiLine, &errorCode);
1443     for (i = 3; i < 6; i++) {
1444         level = ubidi_getLevelAt(bidiLine, i);
1445         if (level != UBIDI_RTL) {
1446             log_err("\nTrailing space at index %d should get paragraph level"
1447                     "%d, got %d instead\n", i, UBIDI_RTL, level);
1448         }
1449     }
1450     RETURN_IF_BAD_ERRCODE("#3#");
1451
1452     srcLen = u_unescape("abc       def", src, MAXLEN);
1453     ubidi_setPara(bidi, src, srcLen, UBIDI_RTL, NULL, &errorCode);
1454     ubidi_setLine(bidi, 0, 6, bidiLine, &errorCode);
1455     for (i = 3; i < 6; i++) {
1456         level = ubidi_getLevelAt(bidiLine, i);
1457         if (level != UBIDI_RTL) {
1458             log_err("\nTrailing space at index %d should get paragraph level"
1459                     "%d, got %d instead\n", i, UBIDI_RTL, level);
1460         }
1461     }
1462     RETURN_IF_BAD_ERRCODE("#4#");
1463
1464     srcLen = u_unescape("abcdefghi    ", src, MAXLEN);
1465     ubidi_setPara(bidi, src, srcLen, UBIDI_RTL, NULL, &errorCode);
1466     ubidi_setLine(bidi, 0, 6, bidiLine, &errorCode);
1467     for (i = 3; i < 6; i++) {
1468         level = ubidi_getLevelAt(bidiLine, i);
1469         if (level != 2) {
1470             log_err("\nTrailing char at index %d should get level 2, "
1471                     "got %d instead\n", i, level);
1472         }
1473     }
1474     RETURN_IF_BAD_ERRCODE("#5#");
1475
1476     ubidi_setReorderingOptions(bidi, UBIDI_OPTION_REMOVE_CONTROLS);
1477     srcLen = u_unescape("\\u200eabc       def", src, MAXLEN);
1478     ubidi_setPara(bidi, src, srcLen, UBIDI_RTL, NULL, &errorCode);
1479     ubidi_setLine(bidi, 0, 6, bidiLine, &errorCode);
1480     destLen = ubidi_getResultLength(bidiLine);
1481     if (destLen != 5) {
1482         log_err("\nWrong result length, should be 5, got %d\n", destLen);
1483     }
1484     RETURN_IF_BAD_ERRCODE("#6#");
1485
1486     srcLen = u_unescape("abcdefghi", src, MAXLEN);
1487     ubidi_setPara(bidi, src, srcLen, UBIDI_LTR, NULL, &errorCode);
1488     ubidi_setLine(bidi, 0, 6, bidiLine, &errorCode);
1489     dir = ubidi_getDirection(bidiLine);
1490     if (dir != UBIDI_LTR) {
1491         log_err("\nWrong direction #1, should be %d, got %d\n",
1492                 UBIDI_LTR, dir);
1493     }
1494     RETURN_IF_BAD_ERRCODE("#7#");
1495
1496     ubidi_setPara(bidi, src, 0, UBIDI_LTR, NULL, &errorCode);
1497     runCount = ubidi_countRuns(bidi, &errorCode);
1498     if (runCount != 0) {
1499         log_err("\nWrong number of runs #1, should be 0, got %d\n", runCount);
1500     }
1501     RETURN_IF_BAD_ERRCODE("#8#");
1502
1503     srcLen = u_unescape("          ", src, MAXLEN);
1504     ubidi_setPara(bidi, src, srcLen, UBIDI_RTL, NULL, &errorCode);
1505     ubidi_setLine(bidi, 0, 6, bidiLine, &errorCode);
1506     runCount = ubidi_countRuns(bidiLine, &errorCode);
1507     if (runCount != 1) {
1508         log_err("\nWrong number of runs #2, should be 1, got %d\n", runCount);
1509     }
1510     RETURN_IF_BAD_ERRCODE("#9#");
1511
1512     srcLen = u_unescape("a\\u05d0        bc", src, MAXLEN);
1513     ubidi_setPara(bidi, src, srcLen, UBIDI_RTL, NULL, &errorCode);
1514     ubidi_setLine(bidi, 0, 6, bidiLine, &errorCode);
1515     dir = ubidi_getDirection(bidi);
1516     if (dir != UBIDI_MIXED) {
1517         log_err("\nWrong direction #2, should be %d, got %d\n",
1518                 UBIDI_MIXED, dir);
1519     }
1520     dir = ubidi_getDirection(bidiLine);
1521     if (dir != UBIDI_MIXED) {
1522         log_err("\nWrong direction #3, should be %d, got %d\n",
1523                 UBIDI_MIXED, dir);
1524     }
1525     runCount = ubidi_countRuns(bidiLine, &errorCode);
1526     if (runCount != 2) {
1527         log_err("\nWrong number of runs #3, should be 2, got %d\n", runCount);
1528     }
1529     RETURN_IF_BAD_ERRCODE("#10#");
1530
1531     ubidi_invertMap(srcMap, map, 5);
1532     if (memcmp(dstMap, map, sizeof(dstMap))) {
1533         log_err("\nUnexpected inverted Map, got ");
1534         for (i = 0; i < 6; i++) {
1535             log_err("%d ", map[i]);
1536         }
1537         log_err("\n");
1538     }
1539
1540     /* test REMOVE_BIDI_CONTROLS together with DO_MIRRORING */
1541     srcLen = u_unescape("abc\\u200e", src, MAXLEN);
1542     ubidi_setPara(bidi, src, srcLen, UBIDI_LTR, NULL, &errorCode);
1543     destLen = ubidi_writeReordered(bidi, dest, MAXLEN,
1544               UBIDI_REMOVE_BIDI_CONTROLS | UBIDI_DO_MIRRORING, &errorCode);
1545     if (destLen != 3 || memcmp(dest, src, 3 * sizeof(UChar))) {
1546         log_err("\nWrong result #1, should be 'abc', got '%s'\n",
1547                 aescstrdup(dest, destLen));
1548     }
1549     RETURN_IF_BAD_ERRCODE("#11#");
1550
1551     /* test inverse Bidi with marks and contextual orientation */
1552     ubidi_setReorderingMode(bidi, UBIDI_REORDER_INVERSE_LIKE_DIRECT);
1553     ubidi_setReorderingOptions(bidi, UBIDI_OPTION_INSERT_MARKS);
1554     ubidi_setPara(bidi, src, 0, UBIDI_DEFAULT_RTL, NULL, &errorCode);
1555     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1556     if (destLen != 0) {
1557         log_err("\nWrong result #2, length should be 0, got %d\n", destLen);
1558     }
1559     RETURN_IF_BAD_ERRCODE("#12#");
1560     srcLen = u_unescape("   ", src, MAXLEN);
1561     ubidi_setPara(bidi, src, srcLen, UBIDI_DEFAULT_RTL, NULL, &errorCode);
1562     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1563     if (destLen != 3 || memcmp(dest, src, destLen * sizeof(UChar))) {
1564         log_err("\nWrong result #3, should be '   ', got '%s'\n",
1565                 aescstrdup(dest, destLen));
1566     }
1567     RETURN_IF_BAD_ERRCODE("#13#");
1568     srcLen = u_unescape("abc", src, MAXLEN);
1569     ubidi_setPara(bidi, src, srcLen, UBIDI_DEFAULT_RTL, NULL, &errorCode);
1570     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1571     if (destLen != 3 || memcmp(dest, src, destLen * sizeof(UChar))) {
1572         log_err("\nWrong result #4, should be 'abc', got '%s'\n",
1573                 aescstrdup(dest, destLen));
1574     }
1575     RETURN_IF_BAD_ERRCODE("#14#");
1576     srcLen = u_unescape("\\u05d0\\u05d1", src, MAXLEN);
1577     ubidi_setPara(bidi, src, srcLen, UBIDI_DEFAULT_RTL, NULL, &errorCode);
1578     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1579     srcLen = u_unescape("\\u05d1\\u05d0", src, MAXLEN);
1580     if (destLen != 2 || memcmp(dest, src, destLen * sizeof(UChar))) {
1581         log_err("\nWrong result #5, should be '%s', got '%s'\n",
1582                 aescstrdup(src, srcLen), aescstrdup(dest, destLen));
1583     }
1584     RETURN_IF_BAD_ERRCODE("#15#");
1585     srcLen = u_unescape("abc \\u05d0\\u05d1", src, MAXLEN);
1586     ubidi_setPara(bidi, src, srcLen, UBIDI_DEFAULT_RTL, NULL, &errorCode);
1587     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1588     srcLen = u_unescape("\\u05d1\\u05d0 abc", src, MAXLEN);
1589     if (destLen != 6 || memcmp(dest, src, destLen * sizeof(UChar))) {
1590         log_err("\nWrong result #6, should be '%s', got '%s'\n",
1591                 aescstrdup(src, srcLen), aescstrdup(dest, destLen));
1592     }
1593     RETURN_IF_BAD_ERRCODE("#16#");
1594     srcLen = u_unescape("\\u05d0\\u05d1 abc", src, MAXLEN);
1595     ubidi_setPara(bidi, src, srcLen, UBIDI_DEFAULT_RTL, NULL, &errorCode);
1596     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1597     srcLen = u_unescape("\\u200fabc \\u05d1\\u05d0", src, MAXLEN);
1598     if (destLen != 7 || memcmp(dest, src, destLen * sizeof(UChar))) {
1599         log_err("\nWrong result #7, should be '%s', got '%s'\n",
1600                 aescstrdup(src, srcLen), aescstrdup(dest, destLen));
1601     }
1602     RETURN_IF_BAD_ERRCODE("#17#");
1603     srcLen = u_unescape("\\u05d0\\u05d1 abc .-=", src, MAXLEN);
1604     ubidi_setPara(bidi, src, srcLen, UBIDI_DEFAULT_RTL, NULL, &errorCode);
1605     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1606     srcLen = u_unescape("\\u200f=-. abc \\u05d1\\u05d0", src, MAXLEN);
1607     if (destLen != 11 || memcmp(dest, src, destLen * sizeof(UChar))) {
1608         log_err("\nWrong result #8, should be '%s', got '%s'\n",
1609                 aescstrdup(src, srcLen), aescstrdup(dest, destLen));
1610     }
1611     RETURN_IF_BAD_ERRCODE("#18#");
1612     ubidi_orderParagraphsLTR(bidi, TRUE);
1613     srcLen = u_unescape("\n\r   \n\rabc\n\\u05d0\\u05d1\rabc \\u05d2\\u05d3\n\r"
1614                         "\\u05d4\\u05d5 abc\n\\u05d6\\u05d7 abc .-=\r\n"
1615                         "-* \\u05d8\\u05d9 abc .-=", src, MAXLEN);
1616     ubidi_setPara(bidi, src, srcLen, UBIDI_DEFAULT_RTL, NULL, &errorCode);
1617     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1618     srcLen = u_unescape("\n\r   \n\rabc\n\\u05d1\\u05d0\r\\u05d3\\u05d2 abc\n\r"
1619                         "\\u200fabc \\u05d5\\u05d4\n\\u200f=-. abc \\u05d7\\u05d6\r\n"
1620                         "\\u200f=-. abc \\u05d9\\u05d8 *-", src, MAXLEN);
1621     if (destLen != 57 || memcmp(dest, src, destLen * sizeof(UChar))) {
1622         log_err("\nWrong result #9, should be '%s', got '%s'\n",
1623                 aescstrdup(src, srcLen), aescstrdup(dest, destLen));
1624     }
1625     RETURN_IF_BAD_ERRCODE("#19#");
1626     srcLen = u_unescape("\\u05d0 \t", src, MAXLEN);
1627     ubidi_setPara(bidi, src, srcLen, UBIDI_LTR, NULL, &errorCode);
1628     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1629     srcLen = u_unescape("\\u05D0\\u200e \t", src, MAXLEN);
1630     if (destLen != 4 || memcmp(dest, src, destLen * sizeof(UChar))) {
1631         log_err("\nWrong result #10, should be '%s', got '%s'\n",
1632                 aescstrdup(src, srcLen), aescstrdup(dest, destLen));
1633     }
1634     RETURN_IF_BAD_ERRCODE("#20#");
1635     srcLen = u_unescape("\\u05d0 123 \t\\u05d1 123 \\u05d2", src, MAXLEN);
1636     ubidi_setPara(bidi, src, srcLen, UBIDI_LTR, NULL, &errorCode);
1637     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1638     srcLen = u_unescape("\\u05d0 \\u200e123\\u200e \t\\u05d2 123 \\u05d1", src, MAXLEN);
1639     if (destLen != 16 || memcmp(dest, src, destLen * sizeof(UChar))) {
1640         log_err("\nWrong result #11, should be '%s', got '%s'\n",
1641                 aescstrdup(src, srcLen), aescstrdup(dest, destLen));
1642     }
1643     RETURN_IF_BAD_ERRCODE("#21#");
1644     srcLen = u_unescape("\\u05d0 123 \\u0660\\u0661 ab", src, MAXLEN);
1645     ubidi_setPara(bidi, src, srcLen, UBIDI_LTR, NULL, &errorCode);
1646     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1647     srcLen = u_unescape("\\u05d0 \\u200e123 \\u200e\\u0660\\u0661 ab", src, MAXLEN);
1648     if (destLen != 13 || memcmp(dest, src, destLen * sizeof(UChar))) {
1649         log_err("\nWrong result #12, should be '%s', got '%s'\n",
1650                 aescstrdup(src, srcLen), aescstrdup(dest, destLen));
1651     }
1652     RETURN_IF_BAD_ERRCODE("#22#");
1653     srcLen = u_unescape("ab \t", src, MAXLEN);
1654     ubidi_setPara(bidi, src, srcLen, UBIDI_RTL, NULL, &errorCode);
1655     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
1656     srcLen = u_unescape("\\u200f\t ab", src, MAXLEN);
1657     if (destLen != 5 || memcmp(dest, src, destLen * sizeof(UChar))) {
1658         log_err("\nWrong result #13, should be '%s', got '%s'\n",
1659                 aescstrdup(src, srcLen), aescstrdup(dest, destLen));
1660     }
1661     RETURN_IF_BAD_ERRCODE("#23#");
1662
1663     /* check exceeding para level */
1664     ubidi_close(bidi);
1665     bidi = ubidi_open();
1666     srcLen = u_unescape("A\\u202a\\u05d0\\u202aC\\u202c\\u05d1\\u202cE", src, MAXLEN);
1667     ubidi_setPara(bidi, src, srcLen, UBIDI_MAX_EXPLICIT_LEVEL - 1, NULL, &errorCode);
1668     level = ubidi_getLevelAt(bidi, 2);
1669     if (level != UBIDI_MAX_EXPLICIT_LEVEL) {
1670         log_err("\nWrong level at index 2\n, should be %d, got %d\n", UBIDI_MAX_EXPLICIT_LEVEL, level);
1671     }
1672     RETURN_IF_BAD_ERRCODE("#24#");
1673
1674     /* check 1-char runs with RUNS_ONLY */
1675     ubidi_setReorderingMode(bidi, UBIDI_REORDER_RUNS_ONLY);
1676     srcLen = u_unescape("a \\u05d0 b \\u05d1 c \\u05d2 d ", src, MAXLEN);
1677     ubidi_setPara(bidi, src, srcLen, UBIDI_LTR, NULL, &errorCode);
1678     runCount = ubidi_countRuns(bidi, &errorCode);
1679     if (runCount != 14) {
1680         log_err("\nWrong number of runs #3, should be 14, got %d\n", runCount);
1681     }
1682     RETURN_IF_BAD_ERRCODE("#25#");
1683
1684     ubidi_close(bidi);
1685     ubidi_close(bidiLine);
1686 }
1687
1688 static void
1689 testFailureRecovery(void) {
1690     UErrorCode errorCode;
1691     UBiDi *bidi, *bidiLine;
1692     UChar src[MAXLEN];
1693     int32_t srcLen;
1694     UBiDiLevel level;
1695     UBiDiReorderingMode rm;
1696     static UBiDiLevel myLevels[3] = {6,5,4};
1697
1698     log_verbose("\nEntering TestFailureRecovery\n\n");
1699     errorCode = U_FILE_ACCESS_ERROR;
1700     if (ubidi_writeReordered(NULL, NULL, 0, 0, &errorCode) != 0) {
1701         log_err("ubidi_writeReordered did not return 0 when passed a failing UErrorCode\n");
1702     }
1703     if (ubidi_writeReverse(NULL, 0, NULL, 0, 0, &errorCode) != 0) {
1704         log_err("ubidi_writeReverse did not return 0 when passed a failing UErrorCode\n");
1705     }
1706     errorCode = U_ZERO_ERROR;
1707     if (ubidi_writeReordered(NULL, NULL, 0, 0, &errorCode) != 0 || errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
1708         log_err("ubidi_writeReordered did not fail as expected\n");
1709     }
1710
1711     bidi = ubidi_open();
1712     srcLen = u_unescape("abc", src, MAXLEN);
1713     errorCode = U_ZERO_ERROR;
1714     ubidi_setPara(bidi, src, srcLen, UBIDI_DEFAULT_LTR - 1, NULL, &errorCode);
1715     if (U_SUCCESS(errorCode)) {
1716         log_err("\nubidi_setPara did not fail when passed too big para level\n");
1717     }
1718     errorCode = U_ZERO_ERROR;
1719     if (ubidi_writeReverse(NULL, 0, NULL, 0, 0, &errorCode) != 0 || errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
1720         log_err("ubidi_writeReverse did not fail as expected\n");
1721     }
1722     bidiLine = ubidi_open();
1723     errorCode = U_ZERO_ERROR;
1724     ubidi_setLine(bidi, 0, 6, bidiLine, &errorCode);
1725     if (U_SUCCESS(errorCode)) {
1726         log_err("\nubidi_setLine did not fail when called before valid setPara()\n");
1727     }
1728     errorCode = U_ZERO_ERROR;
1729     srcLen = u_unescape("abc", src, MAXLEN);
1730     ubidi_setPara(bidi, src, srcLen, UBIDI_LTR + 4, NULL, &errorCode);
1731     level = ubidi_getLevelAt(bidi, 3);
1732     if (level != 0) {
1733         log_err("\nubidi_getLevelAt did not fail when called with bad argument\n");
1734     }
1735     errorCode = U_ZERO_ERROR;
1736     ubidi_close(bidi);
1737     bidi = ubidi_openSized(-1, 0, &errorCode);
1738     if (U_SUCCESS(errorCode)) {
1739         log_err("\nubidi_openSized did not fail when called with bad argument\n");
1740     }
1741     ubidi_close(bidi);
1742     bidi = ubidi_openSized(2, 1, &errorCode);
1743     errorCode = U_ZERO_ERROR;
1744     srcLen = u_unescape("abc", src, MAXLEN);
1745     ubidi_setPara(bidi, src, srcLen, UBIDI_LTR, NULL, &errorCode);
1746     if (U_SUCCESS(errorCode)) {
1747         log_err("\nsetPara did not fail when called with text too long\n");
1748     }
1749     errorCode = U_ZERO_ERROR;
1750     srcLen = u_unescape("=2", src, MAXLEN);
1751     ubidi_setPara(bidi, src, srcLen, UBIDI_RTL, NULL, &errorCode);
1752     ubidi_countRuns(bidi, &errorCode);
1753     if (U_SUCCESS(errorCode)) {
1754         log_err("\nsetPara did not fail when called for too many runs\n");
1755     }
1756     ubidi_close(bidi);
1757     bidi = ubidi_open();
1758     rm = ubidi_getReorderingMode(bidi);
1759     ubidi_setReorderingMode(bidi, UBIDI_REORDER_DEFAULT - 1);
1760     if (rm != ubidi_getReorderingMode(bidi)) {
1761         log_err("\nsetReorderingMode with bad argument #1 should have no effect\n");
1762     }
1763     ubidi_setReorderingMode(bidi, 9999);
1764     if (rm != ubidi_getReorderingMode(bidi)) {
1765         log_err("\nsetReorderingMode with bad argument #2 should have no effect\n");
1766     }
1767
1768     /* Try a surrogate char */
1769     errorCode = U_ZERO_ERROR;
1770     srcLen = u_unescape("\\uD800\\uDC00", src, MAXLEN);
1771     ubidi_setPara(bidi, src, srcLen, UBIDI_RTL, NULL, &errorCode);
1772     if (ubidi_getDirection(bidi) != UBIDI_MIXED) {
1773         log_err("\ngetDirection for 1st surrogate char should be MIXED\n");
1774     }
1775     errorCode = U_ZERO_ERROR;
1776     srcLen = u_unescape("abc", src, MAXLEN);
1777     ubidi_setPara(bidi, src, srcLen, 5, myLevels, &errorCode);
1778     if (U_SUCCESS(errorCode)) {
1779         log_err("\nsetPara did not fail when called with bad levels\n");
1780     }
1781     ubidi_close(bidi);
1782     ubidi_close(bidiLine);
1783
1784     log_verbose("\nExiting TestFailureRecovery\n\n");
1785 }
1786
1787 static void
1788 testMultipleParagraphs(void) {
1789     static const char* const text = "__ABC\\u001c"          /* Para #0 offset 0 */
1790                                     "__\\u05d0DE\\u001c"    /*       1        6 */
1791                                     "__123\\u001c"          /*       2       12 */
1792                                     "\\u000d\\u000a"        /*       3       18 */
1793                                     "FG\\u000d"             /*       4       20 */
1794                                     "\\u000d"               /*       5       23 */
1795                                     "HI\\u000d\\u000a"      /*       6       24 */
1796                                     "\\u000d\\u000a"        /*       7       28 */
1797                                     "\\u000a"               /*       8       30 */
1798                                     "\\u000a"               /*       9       31 */
1799                                     "JK\\u001c";            /*      10       32 */
1800     static const int32_t paraCount=11;
1801     static const int32_t paraBounds[]={0, 6, 12, 18, 20, 23, 24, 28, 30, 31, 32, 35};
1802     static const UBiDiLevel paraLevels[]={UBIDI_LTR, UBIDI_RTL, UBIDI_DEFAULT_LTR, UBIDI_DEFAULT_RTL, 22, 23};
1803     static const UBiDiLevel multiLevels[6][11] = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1804                                                   {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
1805                                                   {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1806                                                   {0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0},
1807                                                   {22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22},
1808                                                   {23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23}};
1809     static const char* const text2 = "\\u05d0 1-2\\u001c\\u0630 1-2\\u001c1-2";
1810     static const UBiDiLevel levels2[] = {1,1,2,2,2,0, 1,1,2,1,2,0, 2,2,2};
1811     static UBiDiLevel myLevels[10] = {0,0,0,0,0,0,0,0,0,0};
1812     static const UChar multiparaTestString[] = {
1813         0x5de, 0x5e0, 0x5e1, 0x5d4, 0x20,  0x5e1, 0x5e4, 0x5da,
1814         0x20,  0xa,   0xa,   0x41,  0x72,  0x74,  0x69,  0x73,
1815         0x74,  0x3a,  0x20,  0x5de, 0x5e0, 0x5e1, 0x5d4, 0x20,
1816         0x5e1, 0x5e4, 0x5da, 0x20,  0xa,   0xa,   0x41,  0x6c,
1817         0x62,  0x75,  0x6d,  0x3a,  0x20,  0x5de, 0x5e0, 0x5e1,
1818         0x5d4, 0x20,  0x5e1, 0x5e4, 0x5da, 0x20,  0xa,   0xa,
1819         0x54,  0x69,  0x6d,  0x65,  0x3a,  0x20,  0x32,  0x3a,
1820         0x32,  0x37,  0xa,  0xa
1821     };
1822     static const UBiDiLevel multiparaTestLevels[] = {
1823         1, 1, 1, 1, 1, 1, 1, 1,
1824         1, 1, 0, 0, 0, 0, 0, 0,
1825         0, 0, 0, 1, 1, 1, 1, 1,
1826         1, 1, 1, 0, 0, 0, 0, 0,
1827         0, 0, 0, 0, 0, 1, 1, 1,
1828         1, 1, 1, 1, 1, 0, 0, 0,
1829         0, 0, 0, 0, 0, 0, 0, 0,
1830         0, 0, 0, 0
1831     };
1832     UBiDiLevel gotLevel;
1833     const UBiDiLevel* gotLevels;
1834     UBool orderParagraphsLTR;
1835     UChar src[MAXLEN], dest[MAXLEN];
1836     UErrorCode errorCode=U_ZERO_ERROR;
1837     UBiDi* pBidi=ubidi_open();
1838     UBiDi* pLine;
1839     int32_t srcSize, count, paraStart, paraLimit, paraIndex, length;
1840     int32_t srcLen, destLen;
1841     int i, j, k;
1842
1843     log_verbose("\nEntering TestMultipleParagraphs\n\n");
1844     u_unescape(text, src, MAXLEN);
1845     srcSize=u_strlen(src);
1846     ubidi_setPara(pBidi, src, srcSize, UBIDI_LTR, NULL, &errorCode);
1847     if(U_FAILURE(errorCode)){
1848         log_err("ubidi_setPara failed, paraLevel=%d, errorCode %s\n",
1849                 UBIDI_LTR, u_errorName(errorCode));
1850         ubidi_close(pBidi);
1851         return;
1852     }
1853     /* check paragraph count and boundaries */
1854     if (paraCount!=(count=ubidi_countParagraphs(pBidi))) {
1855         log_err("ubidi_countParagraphs returned %d, should be %d\n",
1856                 count, paraCount);
1857     }
1858     for (i=0; i<paraCount; i++) {
1859         ubidi_getParagraphByIndex(pBidi, i, &paraStart, &paraLimit, NULL, &errorCode);
1860         if ((paraStart!=paraBounds[i]) || (paraLimit!=paraBounds[i+1])) {
1861             log_err("Found boundaries of paragraph %d: %d-%d; expected: %d-%d\n",
1862                     i, paraStart, paraLimit, paraBounds[i], paraBounds[i+1]);
1863         }
1864     }
1865     errorCode=U_ZERO_ERROR;
1866     /* check with last paragraph not terminated by B */
1867     src[srcSize-1]='L';
1868     ubidi_setPara(pBidi, src, srcSize, UBIDI_LTR, NULL, &errorCode);
1869     if(U_FAILURE(errorCode)){
1870         log_err("2nd ubidi_setPara failed, paraLevel=%d, errorCode %s\n",
1871                 UBIDI_LTR, u_errorName(errorCode));
1872         ubidi_close(pBidi);
1873         return;
1874     }
1875     if (paraCount!=(count=ubidi_countParagraphs(pBidi))) {
1876         log_err("2nd ubidi_countParagraphs returned %d, should be %d\n",
1877                 count, paraCount);
1878     }
1879     i=paraCount-1;
1880     ubidi_getParagraphByIndex(pBidi, i, &paraStart, &paraLimit, NULL, &errorCode);
1881     if ((paraStart!=paraBounds[i]) || (paraLimit!=paraBounds[i+1])) {
1882         log_err("2nd Found boundaries of paragraph %d: %d-%d; expected: %d-%d\n",
1883                 i, paraStart, paraLimit, paraBounds[i], paraBounds[i+1]);
1884     }
1885     errorCode=U_ZERO_ERROR;
1886     /* check paraLevel for all paragraphs under various paraLevel specs */
1887     for (k=0; k<6; k++) {
1888         ubidi_setPara(pBidi, src, srcSize, paraLevels[k], NULL, &errorCode);
1889         for (i=0; i<paraCount; i++) {
1890             paraIndex=ubidi_getParagraph(pBidi, paraBounds[i], NULL, NULL, &gotLevel, &errorCode);
1891             if (paraIndex!=i) {
1892                 log_err("For paraLevel=%d paragraph=%d, found paragraph index=%d expected=%d\n",
1893                         paraLevels[k], i, paraIndex, i);
1894             }
1895             if (gotLevel!=multiLevels[k][i]) {
1896                 log_err("For paraLevel=%d paragraph=%d, found level=%d expected %d\n",
1897                         paraLevels[k], i, gotLevel, multiLevels[k][i]);
1898             }
1899         }
1900         gotLevel=ubidi_getParaLevel(pBidi);
1901         if (gotLevel!=multiLevels[k][0]) {
1902             log_err("For paraLevel=%d getParaLevel=%d, expected %d\n",
1903                     paraLevels[k], gotLevel, multiLevels[k][0]);
1904         }
1905     }
1906     errorCode=U_ZERO_ERROR;
1907     /* check that the result of ubidi_getParaLevel changes if the first
1908      * paragraph has a different level
1909      */
1910     src[0]=0x05d2;                      /* Hebrew letter Gimel */
1911     ubidi_setPara(pBidi, src, srcSize, UBIDI_DEFAULT_LTR, NULL, &errorCode);
1912     gotLevel=ubidi_getParaLevel(pBidi);
1913     if (gotLevel!=UBIDI_RTL) {
1914         log_err("For paraLevel=UBIDI_DEFAULT_LTR getParaLevel=%d, expected=%d\n",
1915                         gotLevel, UBIDI_RTL);
1916     }
1917     errorCode=U_ZERO_ERROR;
1918     /* check that line cannot overlap paragraph boundaries */
1919     pLine=ubidi_open();
1920     i=paraBounds[1];
1921     k=paraBounds[2]+1;
1922     ubidi_setLine(pBidi, i, k, pLine, &errorCode);
1923     if (U_SUCCESS(errorCode)) {
1924         log_err("For line limits %d-%d got success %s\n",
1925                 i, k, u_errorName(errorCode));
1926     }
1927     errorCode=U_ZERO_ERROR;
1928     i=paraBounds[1];
1929     k=paraBounds[2];
1930     ubidi_setLine(pBidi, i, k, pLine, &errorCode);
1931     if (U_FAILURE(errorCode)) {
1932         log_err("For line limits %d-%d got error %s\n",
1933                 i, k, u_errorName(errorCode));
1934         errorCode=U_ZERO_ERROR;
1935     }
1936     /* check level of block separator at end of paragraph when orderParagraphsLTR==FALSE */
1937     ubidi_setPara(pBidi, src, srcSize, UBIDI_RTL, NULL, &errorCode);
1938     /* get levels through para Bidi block */
1939     gotLevels=ubidi_getLevels(pBidi, &errorCode);
1940     if (U_FAILURE(errorCode)) {
1941         log_err("Error on Para getLevels %s\n", u_errorName(errorCode));
1942         ubidi_close(pLine);
1943         ubidi_close(pBidi);
1944         return;
1945     }
1946     for (i=26; i<32; i++) {
1947         if (gotLevels[i]!=UBIDI_RTL) {
1948             log_err("For char %d(%04x), level=%d, expected=%d\n",
1949                     i, src[i], gotLevels[i], UBIDI_RTL);
1950         }
1951     }
1952     /* get levels through para Line block */
1953     i=paraBounds[1];
1954     k=paraBounds[2];
1955     ubidi_setLine(pBidi, i, k, pLine, &errorCode);
1956     if (U_FAILURE(errorCode)) {
1957         log_err("For line limits %d-%d got error %s\n",
1958                 i, k, u_errorName(errorCode));
1959         ubidi_close(pLine);
1960         ubidi_close(pBidi);
1961         return;
1962     }
1963     paraIndex=ubidi_getParagraph(pLine, i, &paraStart, &paraLimit, &gotLevel, &errorCode);
1964     gotLevels=ubidi_getLevels(pLine, &errorCode);
1965     if (U_FAILURE(errorCode)) {
1966         log_err("Error on Line getLevels %s\n", u_errorName(errorCode));
1967         ubidi_close(pLine);
1968         ubidi_close(pBidi);
1969         return;
1970     }
1971     length=ubidi_getLength(pLine);
1972     if ((gotLevel!=UBIDI_RTL) || (gotLevels[length-1]!=UBIDI_RTL)) {
1973         log_err("For paragraph %d with limits %d-%d, paraLevel=%d expected=%d, "
1974                 "level of separator=%d expected=%d\n",
1975                 paraIndex, paraStart, paraLimit, gotLevel, UBIDI_RTL, gotLevels[length-1], UBIDI_RTL);
1976     }
1977     orderParagraphsLTR=ubidi_isOrderParagraphsLTR(pBidi);
1978     if (orderParagraphsLTR) {
1979         log_err("Found orderParagraphsLTR=%d expected=%d\n", orderParagraphsLTR, FALSE);
1980     }
1981     ubidi_orderParagraphsLTR(pBidi, TRUE);
1982     orderParagraphsLTR=ubidi_isOrderParagraphsLTR(pBidi);
1983     if (!orderParagraphsLTR) {
1984         log_err("Found orderParagraphsLTR=%d expected=%d\n", orderParagraphsLTR, TRUE);
1985     }
1986     /* check level of block separator at end of paragraph when orderParagraphsLTR==TRUE */
1987     ubidi_setPara(pBidi, src, srcSize, UBIDI_RTL, NULL, &errorCode);
1988     /* get levels through para Bidi block */
1989     gotLevels=ubidi_getLevels(pBidi, &errorCode);
1990     for (i=26; i<32; i++) {
1991         if (gotLevels[i]!=0) {
1992             log_err("For char %d(%04x), level=%d, expected=%d\n",
1993                     i, src[i], gotLevels[i], 0);
1994         }
1995     }
1996     errorCode=U_ZERO_ERROR;
1997     /* get levels through para Line block */
1998     i=paraBounds[1];
1999     k=paraBounds[2];
2000     ubidi_setLine(pBidi, paraStart, paraLimit, pLine, &errorCode);
2001     paraIndex=ubidi_getParagraph(pLine, i, &paraStart, &paraLimit, &gotLevel, &errorCode);
2002     gotLevels=ubidi_getLevels(pLine, &errorCode);
2003     length=ubidi_getLength(pLine);
2004     if ((gotLevel!=UBIDI_RTL) || (gotLevels[length-1]!=0)) {
2005         log_err("For paragraph %d with limits %d-%d, paraLevel=%d expected=%d, "
2006                 "level of separator=%d expected=%d\n",
2007                 paraIndex, paraStart, paraLimit, gotLevel, UBIDI_RTL, gotLevels[length-1], 0);
2008         log_verbose("levels=");
2009         for (count=0; count<length; count++) {
2010             log_verbose(" %d", gotLevels[count]);
2011         }
2012         log_verbose("\n");
2013     }
2014
2015     /* test that the concatenation of separate invocations of the bidi code
2016      * on each individual paragraph in order matches the levels array that
2017      * results from invoking bidi once over the entire multiparagraph tests
2018      * (with orderParagraphsLTR false, of course)
2019      */
2020     u_unescape(text, src, MAXLEN);      /* restore original content */
2021     srcSize=u_strlen(src);
2022     ubidi_orderParagraphsLTR(pBidi, FALSE);
2023     ubidi_setPara(pBidi, src, srcSize, UBIDI_DEFAULT_RTL, NULL, &errorCode);
2024     gotLevels=ubidi_getLevels(pBidi, &errorCode);
2025     for (i=0; i<paraCount; i++) {
2026         /* use pLine for individual paragraphs */
2027         paraStart = paraBounds[i];
2028         length = paraBounds[i+1] - paraStart;
2029         ubidi_setPara(pLine, src+paraStart, length, UBIDI_DEFAULT_RTL, NULL, &errorCode);
2030         for (j=0; j<length; j++) {
2031             if ((k=ubidi_getLevelAt(pLine, j)) != (gotLevel=gotLevels[paraStart+j])) {
2032                 log_err("Checking paragraph concatenation: for paragraph=%d, "
2033                         "char=%d(%04x), level=%d, expected=%d\n",
2034                         i, j, src[paraStart+j], k, gotLevel);
2035             }
2036         }
2037     }
2038
2039     /* ensure that leading numerics in a paragraph are not treated as arabic
2040        numerals because of arabic text in a preceding paragraph
2041      */
2042     u_unescape(text2, src, MAXLEN);
2043     srcSize=u_strlen(src);
2044     ubidi_orderParagraphsLTR(pBidi, TRUE);
2045     ubidi_setPara(pBidi, src, srcSize, UBIDI_RTL, NULL, &errorCode);
2046     gotLevels=ubidi_getLevels(pBidi, &errorCode);
2047     if (U_FAILURE(errorCode)) {
2048         log_err("Can't get levels. %s\n", u_errorName(errorCode));
2049         return;
2050     }
2051     for (i=0; i<srcSize; i++) {
2052         if (gotLevels[i]!=levels2[i]) {
2053             log_err("Checking leading numerics: for char %d(%04x), level=%d, expected=%d\n",
2054                     i, src[i], gotLevels[i], levels2[i]);
2055         }
2056     }
2057
2058     /* check handling of whitespace before end of paragraph separator when
2059      * orderParagraphsLTR==TRUE, when last paragraph has, and lacks, a terminating B
2060      */
2061     u_memset(src, 0x0020, MAXLEN);
2062     srcSize = 5;
2063     ubidi_orderParagraphsLTR(pBidi, TRUE);
2064     for (i=0x001c; i<=0x0020; i+=(0x0020-0x001c)) {
2065         src[4]=(UChar)i;                /* with and without terminating B */
2066         for (j=0x0041; j<=0x05d0; j+=(0x05d0-0x0041)) {
2067             src[0]=(UChar)j;            /* leading 'A' or Alef */
2068             for (gotLevel=4; gotLevel<=5; gotLevel++) {
2069                 /* test even and odd paraLevel */
2070                 ubidi_setPara(pBidi, src, srcSize, gotLevel, NULL, &errorCode);
2071                 gotLevels=ubidi_getLevels(pBidi, &errorCode);
2072                 for (k=1; k<=3; k++) {
2073                     if (gotLevels[k]!=gotLevel) {
2074                         log_err("Checking trailing spaces: for leading_char=%04x, "
2075                                 "last_char=%04x, index=%d, level=%d, expected=%d\n",
2076                                 src[0], src[4], k, gotLevels[k], gotLevel);
2077                     }
2078                 }
2079             }
2080         }
2081     }
2082
2083     /* check default orientation when inverse bidi and paragraph starts
2084      * with LTR strong char and ends with RTL strong char, with and without
2085      * a terminating B
2086      */
2087     ubidi_setReorderingMode(pBidi, UBIDI_REORDER_INVERSE_LIKE_DIRECT);
2088     srcLen = u_unescape("abc \\u05d2\\u05d1\n", src, MAXLEN);
2089     ubidi_setPara(pBidi, src, srcLen, UBIDI_DEFAULT_LTR, NULL, &errorCode);
2090     destLen = ubidi_writeReordered(pBidi, dest, MAXLEN, 0, &errorCode);
2091     srcLen = u_unescape("\\u05d1\\u05d2 abc\n", src, MAXLEN);
2092     if (memcmp(src, dest, destLen * sizeof(UChar))) {
2093         log_err("\nInvalid output #0, should be '%s', got '%s'\n",
2094                 aescstrdup(src, srcLen), aescstrdup(dest, destLen));
2095     }
2096     srcLen = u_unescape("abc \\u05d2\\u05d1", src, MAXLEN);
2097     ubidi_setPara(pBidi, src, srcLen, UBIDI_DEFAULT_LTR, NULL, &errorCode);
2098     destLen = ubidi_writeReordered(pBidi, dest, MAXLEN, 0, &errorCode);
2099     srcLen = u_unescape("\\u05d1\\u05d2 abc", src, MAXLEN);
2100     if (memcmp(src, dest, destLen * sizeof(UChar))) {
2101         log_err("\nInvalid output #1, should be '%s', got '%s'\n",
2102                 aescstrdup(src, srcLen), aescstrdup(dest, destLen));
2103     }
2104
2105     /* check multiple paragraphs together with explicit levels
2106      */
2107     ubidi_setReorderingMode(pBidi, UBIDI_REORDER_DEFAULT);
2108     srcLen = u_unescape("ab\\u05d1\\u05d2\n\\u05d3\\u05d4123", src, MAXLEN);
2109     ubidi_setPara(pBidi, src, srcLen, UBIDI_LTR, myLevels, &errorCode);
2110     destLen = ubidi_writeReordered(pBidi, dest, MAXLEN, 0, &errorCode);
2111     srcLen = u_unescape("ab\\u05d2\\u05d1\\n123\\u05d4\\u05d3", src, MAXLEN);
2112     if (memcmp(src, dest, destLen * sizeof(UChar))) {
2113         log_err("\nInvalid output #2, should be '%s', got '%s'\n",
2114                 aescstrdup(src, srcLen), aescstrdup(dest, destLen));
2115     }
2116     count = ubidi_countParagraphs(pBidi);
2117     if (count != 2) {
2118         log_err("\nInvalid number of paras, should be 2, got %d\n", count);
2119     }
2120
2121     ubidi_close(pLine);
2122     ubidi_close(pBidi);
2123     log_verbose("\nExiting TestMultipleParagraphs\n\n");
2124
2125     /* check levels in multiple paragraphs with default para level
2126      */
2127     pBidi = ubidi_open();
2128     errorCode = U_ZERO_ERROR;
2129     ubidi_setPara(pBidi, multiparaTestString, LENGTHOF(multiparaTestString),
2130                   UBIDI_DEFAULT_LTR, NULL, &errorCode);
2131     if (U_FAILURE(errorCode)) {
2132         log_err("ubidi_setPara failed for multiparaTestString\n");
2133         ubidi_close(pBidi);
2134         return;
2135     }
2136     gotLevels = ubidi_getLevels(pBidi, &errorCode);
2137     if (U_FAILURE(errorCode)) {
2138         log_err("ubidi_getLevels failed for multiparaTestString\n");
2139         ubidi_close(pBidi);
2140         return;
2141     }
2142     for (i = 0; i < LENGTHOF(multiparaTestString); i++) {
2143         if (gotLevels[i] != multiparaTestLevels[i]) {
2144             log_err("Error on level for multiparaTestString at index %d, "
2145                     "expected=%d, actual=%d\n",
2146                     i, multiparaTestLevels[i], gotLevels[i]);
2147         }
2148     }
2149     ubidi_close(pBidi);
2150
2151 }
2152
2153
2154 /* inverse BiDi ------------------------------------------------------------- */
2155
2156 static int countRoundtrips=0, countNonRoundtrips=0;
2157
2158 #define STRING_TEST_CASE(s) { (s), LENGTHOF(s) }
2159
2160 static void
2161 testInverse(void) {
2162     static const UChar
2163         string0[]={ 0x6c, 0x61, 0x28, 0x74, 0x69, 0x6e, 0x20, 0x5d0, 0x5d1, 0x29, 0x5d2, 0x5d3 },
2164         string1[]={ 0x6c, 0x61, 0x74, 0x20, 0x5d0, 0x5d1, 0x5d2, 0x20, 0x31, 0x32, 0x33 },
2165         string2[]={ 0x6c, 0x61, 0x74, 0x20, 0x5d0, 0x28, 0x5d1, 0x5d2, 0x20, 0x31, 0x29, 0x32, 0x33 },
2166         string3[]={ 0x31, 0x32, 0x33, 0x20, 0x5d0, 0x5d1, 0x5d2, 0x20, 0x34, 0x35, 0x36 },
2167         string4[]={ 0x61, 0x62, 0x20, 0x61, 0x62, 0x20, 0x661, 0x662 };
2168
2169     static const struct {
2170         const UChar *s;
2171         int32_t length;
2172     } testCases[]={
2173         STRING_TEST_CASE(string0),
2174         STRING_TEST_CASE(string1),
2175         STRING_TEST_CASE(string2),
2176         STRING_TEST_CASE(string3),
2177         STRING_TEST_CASE(string4)
2178     };
2179
2180     UBiDi *pBiDi;
2181     UErrorCode errorCode;
2182     int i;
2183
2184     log_verbose("\nEntering TestInverse\n\n");
2185     pBiDi=ubidi_open();
2186     if(pBiDi==NULL) {
2187         log_err("unable to open a UBiDi object (out of memory)\n");
2188         return;
2189     }
2190
2191     log_verbose("inverse Bidi: testInverse(L) with %u test cases ---\n", LENGTHOF(testCases));
2192      for(i=0; i<LENGTHOF(testCases); ++i) {
2193         log_verbose("Testing case %d\n", i);
2194         errorCode=U_ZERO_ERROR;
2195         _testInverseBidi(pBiDi, testCases[i].s, testCases[i].length, 0, &errorCode);
2196     }
2197
2198     log_verbose("inverse Bidi: testInverse(R) with %u test cases ---\n", LENGTHOF(testCases));
2199     for(i=0; i<LENGTHOF(testCases); ++i) {
2200         log_verbose("Testing case %d\n", i);
2201         errorCode=U_ZERO_ERROR;
2202         _testInverseBidi(pBiDi, testCases[i].s, testCases[i].length, 1, &errorCode);
2203     }
2204
2205     _testManyInverseBidi(pBiDi, 0);
2206     _testManyInverseBidi(pBiDi, 1);
2207
2208     ubidi_close(pBiDi);
2209
2210     log_verbose("inverse Bidi: rountrips: %5u\nnon-roundtrips: %5u\n", countRoundtrips, countNonRoundtrips);
2211
2212     _testWriteReverse();
2213
2214     _testManyAddedPoints();
2215
2216     _testMisc();
2217
2218     log_verbose("\nExiting TestInverse\n\n");
2219 }
2220
2221 #define COUNT_REPEAT_SEGMENTS 6
2222
2223 static const UChar repeatSegments[COUNT_REPEAT_SEGMENTS][2]={
2224     { 0x61, 0x62 },     /* L */
2225     { 0x5d0, 0x5d1 },   /* R */
2226     { 0x627, 0x628 },   /* AL */
2227     { 0x31, 0x32 },     /* EN */
2228     { 0x661, 0x662 },   /* AN */
2229     { 0x20, 0x20 }      /* WS (N) */
2230 };
2231
2232 static void
2233 _testManyInverseBidi(UBiDi *pBiDi, UBiDiLevel direction) {
2234     UChar text[8]={ 0, 0, 0x20, 0, 0, 0x20, 0, 0 };
2235     int i, j, k;
2236     UErrorCode errorCode;
2237
2238     log_verbose("inverse Bidi: testManyInverseBidi(%c) - test permutations of text snippets ---\n",
2239                  direction==0 ? 'L' : 'R');
2240     for(i=0; i<COUNT_REPEAT_SEGMENTS; ++i) {
2241         text[0]=repeatSegments[i][0];
2242         text[1]=repeatSegments[i][1];
2243         for(j=0; j<COUNT_REPEAT_SEGMENTS; ++j) {
2244             text[3]=repeatSegments[j][0];
2245             text[4]=repeatSegments[j][1];
2246             for(k=0; k<COUNT_REPEAT_SEGMENTS; ++k) {
2247                 text[6]=repeatSegments[k][0];
2248                 text[7]=repeatSegments[k][1];
2249
2250                 errorCode=U_ZERO_ERROR;
2251                 log_verbose("inverse Bidi: testManyInverseBidi()[%u %u %u]\n", i, j, k);
2252                 _testInverseBidi(pBiDi, text, 8, direction, &errorCode);
2253             }
2254         }
2255     }
2256 }
2257
2258 static void
2259 _testInverseBidi(UBiDi *pBiDi, const UChar *src, int32_t srcLength,
2260                 UBiDiLevel direction, UErrorCode *pErrorCode) {
2261     UChar visualLTR[MAXLEN], logicalDest[MAXLEN], visualDest[MAXLEN];
2262     int32_t ltrLength, logicalLength, visualLength;
2263
2264     if(direction==0) {
2265         log_verbose("inverse Bidi: testInverse(L)\n");
2266
2267         /* convert visual to logical */
2268         ubidi_setInverse(pBiDi, TRUE);
2269         if (!ubidi_isInverse(pBiDi)) {
2270             log_err("Error while doing ubidi_setInverse(TRUE)\n");
2271         }
2272         ubidi_setPara(pBiDi, src, srcLength, 0, NULL, pErrorCode);
2273         if (src != ubidi_getText(pBiDi)) {
2274             log_err("Wrong value returned by ubidi_getText\n");
2275         }
2276         logicalLength=ubidi_writeReordered(pBiDi, logicalDest, LENGTHOF(logicalDest),
2277                                            UBIDI_DO_MIRRORING|UBIDI_INSERT_LRM_FOR_NUMERIC, pErrorCode);
2278         log_verbose("  v ");
2279         printUnicode(src, srcLength, ubidi_getLevels(pBiDi, pErrorCode));
2280         log_verbose("\n");
2281
2282         /* convert back to visual LTR */
2283         ubidi_setInverse(pBiDi, FALSE);
2284         if (ubidi_isInverse(pBiDi)) {
2285             log_err("Error while doing ubidi_setInverse(FALSE)\n");
2286         }
2287         ubidi_setPara(pBiDi, logicalDest, logicalLength, 0, NULL, pErrorCode);
2288         visualLength=ubidi_writeReordered(pBiDi, visualDest, LENGTHOF(visualDest),
2289                                           UBIDI_DO_MIRRORING|UBIDI_REMOVE_BIDI_CONTROLS, pErrorCode);
2290     } else {
2291         log_verbose("inverse Bidi: testInverse(R)\n");
2292
2293         /* reverse visual from RTL to LTR */
2294         ltrLength=ubidi_writeReverse(src, srcLength, visualLTR, LENGTHOF(visualLTR), 0, pErrorCode);
2295         log_verbose("  vr");
2296         printUnicode(src, srcLength, NULL);
2297         log_verbose("\n");
2298
2299         /* convert visual RTL to logical */
2300         ubidi_setInverse(pBiDi, TRUE);
2301         ubidi_setPara(pBiDi, visualLTR, ltrLength, 0, NULL, pErrorCode);
2302         logicalLength=ubidi_writeReordered(pBiDi, logicalDest, LENGTHOF(logicalDest),
2303                                            UBIDI_DO_MIRRORING|UBIDI_INSERT_LRM_FOR_NUMERIC, pErrorCode);
2304         log_verbose("  vl");
2305         printUnicode(visualLTR, ltrLength, ubidi_getLevels(pBiDi, pErrorCode));
2306         log_verbose("\n");
2307
2308         /* convert back to visual RTL */
2309         ubidi_setInverse(pBiDi, FALSE);
2310         ubidi_setPara(pBiDi, logicalDest, logicalLength, 0, NULL, pErrorCode);
2311         visualLength=ubidi_writeReordered(pBiDi, visualDest, LENGTHOF(visualDest),
2312                                           UBIDI_DO_MIRRORING|UBIDI_REMOVE_BIDI_CONTROLS|UBIDI_OUTPUT_REVERSE, pErrorCode);
2313     }
2314     log_verbose("  l ");
2315     printUnicode(logicalDest, logicalLength, ubidi_getLevels(pBiDi, pErrorCode));
2316     log_verbose("\n");
2317     log_verbose("  v ");
2318     printUnicode(visualDest, visualLength, NULL);
2319     log_verbose("\n");
2320
2321     /* check and print results */
2322     if(U_FAILURE(*pErrorCode)) {
2323         log_err("inverse BiDi: *** error %s\n"
2324                 "                 turn on verbose mode to see details\n", u_errorName(*pErrorCode));
2325     } else if(srcLength==visualLength && memcmp(src, visualDest, srcLength*U_SIZEOF_UCHAR)==0) {
2326         ++countRoundtrips;
2327         log_verbose(" + roundtripped\n");
2328     } else {
2329         ++countNonRoundtrips;
2330         log_verbose(" * did not roundtrip\n");
2331         log_err("inverse BiDi: transformation visual->logical->visual did not roundtrip the text;\n"
2332                 "                 turn on verbose mode to see details\n");
2333     }
2334 }
2335
2336 static void
2337 _testWriteReverse(void) {
2338     /* U+064e and U+0650 are combining marks (Mn) */
2339     static const UChar forward[]={
2340         0x200f, 0x627, 0x64e, 0x650, 0x20, 0x28, 0x31, 0x29
2341     }, reverseKeepCombining[]={
2342         0x29, 0x31, 0x28, 0x20, 0x627, 0x64e, 0x650, 0x200f
2343     }, reverseRemoveControlsKeepCombiningDoMirror[]={
2344         0x28, 0x31, 0x29, 0x20, 0x627, 0x64e, 0x650
2345     };
2346     UChar reverse[10];
2347     UErrorCode errorCode;
2348     int32_t length;
2349
2350     /* test ubidi_writeReverse() with "interesting" options */
2351     errorCode=U_ZERO_ERROR;
2352     length=ubidi_writeReverse(forward, LENGTHOF(forward),
2353                               reverse, LENGTHOF(reverse),
2354                               UBIDI_KEEP_BASE_COMBINING,
2355                               &errorCode);
2356     if(U_FAILURE(errorCode) || length!=LENGTHOF(reverseKeepCombining) || memcmp(reverse, reverseKeepCombining, length*U_SIZEOF_UCHAR)!=0) {
2357         log_err("failure in ubidi_writeReverse(UBIDI_KEEP_BASE_COMBINING): length=%d (should be %d), error code %s\n",
2358                 length, LENGTHOF(reverseKeepCombining), u_errorName(errorCode));
2359     }
2360
2361     memset(reverse, 0xa5, LENGTHOF(reverse)*U_SIZEOF_UCHAR);
2362     errorCode=U_ZERO_ERROR;
2363     length=ubidi_writeReverse(forward, LENGTHOF(forward),
2364                               reverse, LENGTHOF(reverse),
2365                               UBIDI_REMOVE_BIDI_CONTROLS|UBIDI_DO_MIRRORING|UBIDI_KEEP_BASE_COMBINING,
2366                               &errorCode);
2367     if(U_FAILURE(errorCode) || length!=LENGTHOF(reverseRemoveControlsKeepCombiningDoMirror) || memcmp(reverse, reverseRemoveControlsKeepCombiningDoMirror, length*U_SIZEOF_UCHAR)!=0) {
2368         log_err("failure in ubidi_writeReverse(UBIDI_REMOVE_BIDI_CONTROLS|UBIDI_DO_MIRRORING|UBIDI_KEEP_BASE_COMBINING):\n"
2369                 "    length=%d (should be %d), error code %s\n",
2370                 length, LENGTHOF(reverseRemoveControlsKeepCombiningDoMirror), u_errorName(errorCode));
2371     }
2372 }
2373
2374 static void _testManyAddedPoints(void) {
2375     UErrorCode errorCode = U_ZERO_ERROR;
2376     UBiDi *bidi = ubidi_open();
2377     UChar text[90], dest[MAXLEN], expected[120];
2378     int destLen, i;
2379     for (i = 0; i < LENGTHOF(text); i+=3) {
2380         text[i] = 0x0061; /* 'a' */
2381         text[i+1] = 0x05d0;
2382         text[i+2] = 0x0033; /* '3' */
2383     }
2384     ubidi_setReorderingMode(bidi, UBIDI_REORDER_INVERSE_LIKE_DIRECT);
2385     ubidi_setReorderingOptions(bidi, UBIDI_OPTION_INSERT_MARKS);
2386     ubidi_setPara(bidi, text, LENGTHOF(text), UBIDI_LTR, NULL, &errorCode);
2387     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
2388     for (i = 0; i < LENGTHOF(expected); i+=4) {
2389         expected[i] = 0x0061; /* 'a' */
2390         expected[i+1] = 0x05d0;
2391         expected[i+2] = 0x200e;
2392         expected[i+3] = 0x0033; /* '3' */
2393     }
2394     if (memcmp(dest, expected, destLen * sizeof(UChar))) {
2395         log_err("\nInvalid output with many added points, "
2396                 "expected '%s', got '%s'\n",
2397                 aescstrdup(expected, LENGTHOF(expected)),
2398                 aescstrdup(dest, destLen));
2399     }
2400     ubidi_close(bidi);
2401 }
2402
2403 static void _testMisc(void) {
2404     UErrorCode errorCode = U_ZERO_ERROR;
2405     UBiDi *bidi = ubidi_open();
2406     UChar src[3], dest[MAXLEN], expected[5];
2407     int destLen;
2408     ubidi_setInverse(bidi, TRUE);
2409     src[0] = src[1] = src[2] = 0x0020;
2410     ubidi_setPara(bidi, src, LENGTHOF(src), UBIDI_RTL, NULL, &errorCode);
2411     destLen = ubidi_writeReordered(bidi, dest, MAXLEN,
2412               UBIDI_OUTPUT_REVERSE | UBIDI_INSERT_LRM_FOR_NUMERIC,
2413               &errorCode);
2414     u_unescape("\\u200f   \\u200f", expected, 5);
2415     if (memcmp(dest, expected, destLen * sizeof(UChar))) {
2416         log_err("\nInvalid output with RLM at both sides, "
2417                 "expected '%s', got '%s'\n",
2418                 aescstrdup(expected, LENGTHOF(expected)),
2419                 aescstrdup(dest, destLen));
2420     }
2421     ubidi_close(bidi);
2422 }
2423
2424 /* arabic shaping ----------------------------------------------------------- */
2425
2426 static void
2427 doArabicShapingTest(void) {
2428     static const UChar
2429     source[]={
2430         0x31,   /* en:1 */
2431         0x627,  /* arabic:alef */
2432         0x32,   /* en:2 */
2433         0x6f3,  /* an:3 */
2434         0x61,   /* latin:a */
2435         0x34,   /* en:4 */
2436         0
2437     }, en2an[]={
2438         0x661, 0x627, 0x662, 0x6f3, 0x61, 0x664, 0
2439     }, an2en[]={
2440         0x31, 0x627, 0x32, 0x33, 0x61, 0x34, 0
2441     }, logical_alen2an_init_lr[]={
2442         0x31, 0x627, 0x662, 0x6f3, 0x61, 0x34, 0
2443     }, logical_alen2an_init_al[]={
2444         0x6f1, 0x627, 0x6f2, 0x6f3, 0x61, 0x34, 0
2445     }, reverse_alen2an_init_lr[]={
2446         0x661, 0x627, 0x32, 0x6f3, 0x61, 0x34, 0
2447     }, reverse_alen2an_init_al[]={
2448         0x6f1, 0x627, 0x32, 0x6f3, 0x61, 0x6f4, 0
2449     }, lamalef[]={
2450         0xfefb, 0
2451     };
2452     UChar dest[8];
2453     UErrorCode errorCode;
2454     int32_t length;
2455
2456     /* test number shaping */
2457
2458     /* european->arabic */
2459     errorCode=U_ZERO_ERROR;
2460     length=u_shapeArabic(source, LENGTHOF(source),
2461                          dest, LENGTHOF(dest),
2462                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2463                          &errorCode);
2464     if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, en2an, length*U_SIZEOF_UCHAR)!=0) {
2465         log_err("failure in u_shapeArabic(en2an)\n");
2466     }
2467
2468     /* arabic->european */
2469     errorCode=U_ZERO_ERROR;
2470     length=u_shapeArabic(source, -1,
2471                          dest, LENGTHOF(dest),
2472                          U_SHAPE_DIGITS_AN2EN|U_SHAPE_DIGIT_TYPE_AN_EXTENDED,
2473                          &errorCode);
2474     if(U_FAILURE(errorCode) || length!=u_strlen(source) || memcmp(dest, an2en, length*U_SIZEOF_UCHAR)!=0) {
2475         log_err("failure in u_shapeArabic(an2en)\n");
2476     }
2477
2478     /* european->arabic with context, logical order, initial state not AL */
2479     errorCode=U_ZERO_ERROR;
2480     length=u_shapeArabic(source, LENGTHOF(source),
2481                          dest, LENGTHOF(dest),
2482                          U_SHAPE_DIGITS_ALEN2AN_INIT_LR|U_SHAPE_DIGIT_TYPE_AN,
2483                          &errorCode);
2484     if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, logical_alen2an_init_lr, length*U_SIZEOF_UCHAR)!=0) {
2485         log_err("failure in u_shapeArabic(logical_alen2an_init_lr)\n");
2486     }
2487
2488     /* european->arabic with context, logical order, initial state AL */
2489     errorCode=U_ZERO_ERROR;
2490     length=u_shapeArabic(source, LENGTHOF(source),
2491                          dest, LENGTHOF(dest),
2492                          U_SHAPE_DIGITS_ALEN2AN_INIT_AL|U_SHAPE_DIGIT_TYPE_AN_EXTENDED,
2493                          &errorCode);
2494     if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, logical_alen2an_init_al, length*U_SIZEOF_UCHAR)!=0) {
2495         log_err("failure in u_shapeArabic(logical_alen2an_init_al)\n");
2496     }
2497
2498     /* european->arabic with context, reverse order, initial state not AL */
2499     errorCode=U_ZERO_ERROR;
2500     length=u_shapeArabic(source, LENGTHOF(source),
2501                          dest, LENGTHOF(dest),
2502                          U_SHAPE_DIGITS_ALEN2AN_INIT_LR|U_SHAPE_DIGIT_TYPE_AN|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2503                          &errorCode);
2504     if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, reverse_alen2an_init_lr, length*U_SIZEOF_UCHAR)!=0) {
2505         log_err("failure in u_shapeArabic(reverse_alen2an_init_lr)\n");
2506     }
2507
2508     /* european->arabic with context, reverse order, initial state AL */
2509     errorCode=U_ZERO_ERROR;
2510     length=u_shapeArabic(source, LENGTHOF(source),
2511                          dest, LENGTHOF(dest),
2512                          U_SHAPE_DIGITS_ALEN2AN_INIT_AL|U_SHAPE_DIGIT_TYPE_AN_EXTENDED|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2513                          &errorCode);
2514     if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, reverse_alen2an_init_al, length*U_SIZEOF_UCHAR)!=0) {
2515         log_err("failure in u_shapeArabic(reverse_alen2an_init_al)\n");
2516     }
2517
2518     /* test noop */
2519     errorCode=U_ZERO_ERROR;
2520     length=u_shapeArabic(source, LENGTHOF(source),
2521                          dest, LENGTHOF(dest),
2522                          0,
2523                          &errorCode);
2524     if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, source, length*U_SIZEOF_UCHAR)!=0) {
2525         log_err("failure in u_shapeArabic(noop)\n");
2526     }
2527
2528     errorCode=U_ZERO_ERROR;
2529     length=u_shapeArabic(source, 0,
2530                          dest, LENGTHOF(dest),
2531                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2532                          &errorCode);
2533     if(U_FAILURE(errorCode) || length!=0) {
2534         log_err("failure in u_shapeArabic(en2an, sourceLength=0), returned %d/%s\n", u_errorName(errorCode), LENGTHOF(source));
2535     }
2536
2537     /* preflight digit shaping */
2538     errorCode=U_ZERO_ERROR;
2539     length=u_shapeArabic(source, LENGTHOF(source),
2540                          NULL, 0,
2541                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2542                          &errorCode);
2543     if(errorCode!=U_BUFFER_OVERFLOW_ERROR || length!=LENGTHOF(source)) {
2544         log_err("failure in u_shapeArabic(en2an preflighting), returned %d/%s instead of %d/U_BUFFER_OVERFLOW_ERROR\n",
2545                 length, u_errorName(errorCode), LENGTHOF(source));
2546     }
2547
2548     /* test illegal arguments */
2549     errorCode=U_ZERO_ERROR;
2550     length=u_shapeArabic(NULL, LENGTHOF(source),
2551                          dest, LENGTHOF(dest),
2552                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2553                          &errorCode);
2554     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2555         log_err("failure in u_shapeArabic(source=NULL), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2556     }
2557
2558     errorCode=U_ZERO_ERROR;
2559     length=u_shapeArabic(source, -2,
2560                          dest, LENGTHOF(dest),
2561                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2562                          &errorCode);
2563     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2564         log_err("failure in u_shapeArabic(sourceLength=-2), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2565     }
2566
2567     errorCode=U_ZERO_ERROR;
2568     length=u_shapeArabic(source, LENGTHOF(source),
2569                          NULL, LENGTHOF(dest),
2570                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2571                          &errorCode);
2572     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2573         log_err("failure in u_shapeArabic(dest=NULL), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2574     }
2575
2576     errorCode=U_ZERO_ERROR;
2577     length=u_shapeArabic(source, LENGTHOF(source),
2578                          dest, -1,
2579                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2580                          &errorCode);
2581     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2582         log_err("failure in u_shapeArabic(destSize=-1), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2583     }
2584
2585     errorCode=U_ZERO_ERROR;
2586     length=u_shapeArabic(source, LENGTHOF(source),
2587                          dest, LENGTHOF(dest),
2588                          U_SHAPE_DIGITS_RESERVED|U_SHAPE_DIGIT_TYPE_AN,
2589                          &errorCode);
2590     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2591         log_err("failure in u_shapeArabic(U_SHAPE_DIGITS_RESERVED), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2592     }
2593
2594     errorCode=U_ZERO_ERROR;
2595     length=u_shapeArabic(source, LENGTHOF(source),
2596                          dest, LENGTHOF(dest),
2597                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_RESERVED,
2598                          &errorCode);
2599     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2600         log_err("failure in u_shapeArabic(U_SHAPE_DIGIT_TYPE_RESERVED), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2601     }
2602
2603     errorCode=U_ZERO_ERROR;
2604     length=u_shapeArabic(source, LENGTHOF(source),
2605                          (UChar *)(source+2), LENGTHOF(dest), /* overlap source and destination */
2606                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
2607                          &errorCode);
2608     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
2609         log_err("failure in u_shapeArabic(U_SHAPE_DIGIT_TYPE_RESERVED), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
2610     }
2611
2612     errorCode=U_ZERO_ERROR;
2613     length=u_shapeArabic(lamalef, LENGTHOF(lamalef),
2614                          dest, LENGTHOF(dest),
2615                          U_SHAPE_LETTERS_UNSHAPE | U_SHAPE_LENGTH_GROW_SHRINK | U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2616                          &errorCode);
2617     if(U_FAILURE(errorCode) || length == LENGTHOF(lamalef)) {
2618         log_err("failure in u_shapeArabic(U_SHAPE_LETTERS_UNSHAPE | U_SHAPE_LENGTH_GROW_SHRINK | U_SHAPE_TEXT_DIRECTION_VISUAL_LTR)\n");
2619         log_err("returned %s instead of U_ZERO_ERROR or returned length %d instead of 3\n", u_errorName(errorCode), length);
2620     }
2621 }
2622
2623 static void
2624 doLamAlefSpecialVLTRArabicShapingTest(void) {
2625     static const UChar
2626     source[]={
2627 /*a*/   0x20 ,0x646,0x622,0x644,0x627,0x20,
2628 /*b*/   0x646,0x623,0x64E,0x644,0x627,0x20,
2629 /*c*/   0x646,0x627,0x670,0x644,0x627,0x20,
2630 /*d*/   0x646,0x622,0x653,0x644,0x627,0x20,
2631 /*e*/   0x646,0x625,0x655,0x644,0x627,0x20,
2632 /*f*/   0x646,0x622,0x654,0x644,0x627,0x20,
2633 /*g*/   0xFEFC,0x639
2634     }, shape_near[]={
2635         0x20,0xfee5,0x20,0xfef5,0xfe8d,0x20,0xfee5,0x20,0xfe76,0xfef7,0xfe8d,0x20,
2636         0xfee5,0x20,0x670,0xfefb,0xfe8d,0x20,0xfee5,0x20,0x653,0xfef5,0xfe8d,0x20,
2637         0xfee5,0x20,0x655,0xfef9,0xfe8d,0x20,0xfee5,0x20,0x654,0xfef5,0xfe8d,0x20,
2638         0xfefc,0xfecb
2639     }, shape_at_end[]={
2640         0x20,0xfee5,0xfef5,0xfe8d,0x20,0xfee5,0xfe76,0xfef7,0xfe8d,0x20,0xfee5,0x670,
2641         0xfefb,0xfe8d,0x20,0xfee5,0x653,0xfef5,0xfe8d,0x20,0xfee5,0x655,0xfef9,0xfe8d,
2642         0x20,0xfee5,0x654,0xfef5,0xfe8d,0x20,0xfefc,0xfecb,0x20,0x20,0x20,0x20,0x20,0x20
2643     }, shape_at_begin[]={
2644         0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xfee5,0xfef5,0xfe8d,0x20,0xfee5,0xfe76,
2645         0xfef7,0xfe8d,0x20,0xfee5,0x670,0xfefb,0xfe8d,0x20,0xfee5,0x653,0xfef5,0xfe8d,
2646         0x20,0xfee5,0x655,0xfef9,0xfe8d,0x20,0xfee5,0x654,0xfef5,0xfe8d,0x20,0xfefc,0xfecb
2647     }, shape_grow_shrink[]={
2648         0x20,0xfee5,0xfef5,0xfe8d,0x20,0xfee5,0xfe76,0xfef7,0xfe8d,0x20,0xfee5,
2649         0x670,0xfefb,0xfe8d,0x20,0xfee5,0x653,0xfef5,0xfe8d,0x20,0xfee5,0x655,0xfef9,
2650         0xfe8d,0x20,0xfee5,0x654,0xfef5,0xfe8d,0x20,0xfefc,0xfecb
2651     }, shape_excepttashkeel_near[]={
2652         0x20,0xfee5,0x20,0xfef5,0xfe8d,0x20,0xfee5,0x20,0xfe76,0xfef7,0xfe8d,0x20,
2653         0xfee5,0x20,0x670,0xfefb,0xfe8d,0x20,0xfee5,0x20,0x653,0xfef5,0xfe8d,0x20,
2654         0xfee5,0x20,0x655,0xfef9,0xfe8d,0x20,0xfee5,0x20,0x654,0xfef5,0xfe8d,0x20,
2655         0xfefc,0xfecb
2656     }, shape_excepttashkeel_at_end[]={
2657         0x20,0xfee5,0xfef5,0xfe8d,0x20,0xfee5,0xfe76,0xfef7,0xfe8d,0x20,0xfee5,
2658         0x670,0xfefb,0xfe8d,0x20,0xfee5,0x653,0xfef5,0xfe8d,0x20,0xfee5,0x655,0xfef9,
2659         0xfe8d,0x20,0xfee5,0x654,0xfef5,0xfe8d,0x20,0xfefc,0xfecb,0x20,0x20,0x20,
2660         0x20,0x20,0x20
2661     }, shape_excepttashkeel_at_begin[]={
2662         0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xfee5,0xfef5,0xfe8d,0x20,0xfee5,0xfe76,
2663         0xfef7,0xfe8d,0x20,0xfee5,0x670,0xfefb,0xfe8d,0x20,0xfee5,0x653,0xfef5,0xfe8d,
2664         0x20,0xfee5,0x655,0xfef9,0xfe8d,0x20,0xfee5,0x654,0xfef5,0xfe8d,0x20,0xfefc,0xfecb
2665     }, shape_excepttashkeel_grow_shrink[]={
2666         0x20,0xfee5,0xfef5,0xfe8d,0x20,0xfee5,0xfe76,0xfef7,0xfe8d,0x20,0xfee5,0x670,
2667         0xfefb,0xfe8d,0x20,0xfee5,0x653,0xfef5,0xfe8d,0x20,0xfee5,0x655,0xfef9,0xfe8d,
2668         0x20,0xfee5,0x654,0xfef5,0xfe8d,0x20,0xfefc,0xfecb
2669     };
2670
2671     UChar dest[38];
2672     UErrorCode errorCode;
2673     int32_t length;
2674
2675     errorCode=U_ZERO_ERROR;
2676
2677     length=u_shapeArabic(source, LENGTHOF(source),
2678                          dest, LENGTHOF(dest),
2679                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_NEAR|
2680                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2681                          &errorCode);
2682
2683     if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_near) || memcmp(dest, shape_near, length*U_SIZEOF_UCHAR)!=0) {
2684         log_err("failure in u_shapeArabic(LAMALEF shape_near)\n");
2685     }
2686
2687     errorCode=U_ZERO_ERROR;
2688
2689     length=u_shapeArabic(source, LENGTHOF(source),
2690                          dest, LENGTHOF(dest),
2691                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_END|
2692                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2693                          &errorCode);
2694
2695     if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_at_end) || memcmp(dest, shape_at_end, length*U_SIZEOF_UCHAR)!=0) {
2696         log_err("failure in u_shapeArabic(LAMALEF shape_at_end)\n");
2697     }
2698
2699     errorCode=U_ZERO_ERROR;
2700
2701     length=u_shapeArabic(source, LENGTHOF(source),
2702                          dest, LENGTHOF(dest),
2703                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_BEGINNING|
2704                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2705                          &errorCode);
2706
2707     if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_at_begin) || memcmp(dest, shape_at_begin, length*U_SIZEOF_UCHAR)!=0) {
2708         log_err("failure in u_shapeArabic(LAMALEF shape_at_begin)\n");
2709     }
2710
2711     errorCode=U_ZERO_ERROR;
2712
2713     length=u_shapeArabic(source, LENGTHOF(source),
2714                          dest, LENGTHOF(dest),
2715                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_GROW_SHRINK|
2716                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2717                          &errorCode);
2718
2719     if(U_FAILURE(errorCode) || memcmp(dest, shape_grow_shrink, length*U_SIZEOF_UCHAR)!=0) {
2720         log_err("failure in u_shapeArabic(LAMALEF shape_grow_shrink)\n");
2721     }
2722
2723     /* ==================== U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED ==================== */
2724
2725     errorCode=U_ZERO_ERROR;
2726
2727     length=u_shapeArabic(source, LENGTHOF(source),
2728                          dest, LENGTHOF(dest),
2729                          U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_FIXED_SPACES_NEAR|
2730                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2731                          &errorCode);
2732
2733     if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_excepttashkeel_near) || memcmp(dest, shape_excepttashkeel_near, length*U_SIZEOF_UCHAR)!=0) {
2734         log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_near)\n");
2735     }
2736
2737     errorCode=U_ZERO_ERROR;
2738
2739     length=u_shapeArabic(source, LENGTHOF(source),
2740                          dest, LENGTHOF(dest),
2741                          U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_FIXED_SPACES_AT_END|
2742                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2743                          &errorCode);
2744
2745     if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_excepttashkeel_at_end) || memcmp(dest,shape_excepttashkeel_at_end , length*U_SIZEOF_UCHAR)!=0) {
2746         log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_at_end)\n");
2747     }
2748
2749     errorCode=U_ZERO_ERROR;
2750
2751     length=u_shapeArabic(source, LENGTHOF(source),
2752                          dest, LENGTHOF(dest),
2753                          U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_FIXED_SPACES_AT_BEGINNING|
2754                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2755                          &errorCode);
2756
2757     if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_excepttashkeel_at_begin) || memcmp(dest, shape_excepttashkeel_at_begin, length*U_SIZEOF_UCHAR)!=0) {
2758         log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_at_begin)\n");
2759     }
2760
2761     errorCode=U_ZERO_ERROR;
2762
2763     length=u_shapeArabic(source, LENGTHOF(source),
2764                          dest, LENGTHOF(dest),
2765                          U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_GROW_SHRINK|
2766                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2767                          &errorCode);
2768
2769     if(U_FAILURE(errorCode) || memcmp(dest, shape_excepttashkeel_grow_shrink, length*U_SIZEOF_UCHAR)!=0) {
2770         log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_grow_shrink)\n");
2771     }
2772 }
2773
2774 static void
2775 doTashkeelSpecialVLTRArabicShapingTest(void) {
2776     static const UChar
2777     source[]={
2778         0x64A,0x628,0x631,0x639,0x20,
2779         0x64A,0x628,0x651,0x631,0x64E,0x639,0x20,
2780         0x64C,0x64A,0x628,0x631,0x64F,0x639,0x20,
2781         0x628,0x670,0x631,0x670,0x639,0x20,
2782         0x628,0x653,0x631,0x653,0x639,0x20,
2783         0x628,0x654,0x631,0x654,0x639,0x20,
2784         0x628,0x655,0x631,0x655,0x639,0x20,
2785     }, shape_near[]={
2786         0xfef2,0xfe91,0xfeae,0xfecb,0x20,0xfef2,0xfe91,0xfe7c,0xfeae,0xfe77,0xfecb,
2787         0x20,0xfe72,0xfef2,0xfe91,0xfeae,0xfe79,0xfecb,0x20,0xfe8f,0x670,0xfeae,0x670,
2788         0xfecb,0x20,0xfe8f,0x653,0xfeae,0x653,0xfecb,0x20,0xfe8f,0x654,0xfeae,0x654,
2789         0xfecb,0x20,0xfe8f,0x655,0xfeae,0x655,0xfecb,0x20
2790     }, shape_excepttashkeel_near[]={
2791         0xfef2,0xfe91,0xfeae,0xfecb,0x20,0xfef2,0xfe91,0xfe7c,0xfeae,0xfe76,0xfecb,0x20,
2792         0xfe72,0xfef2,0xfe91,0xfeae,0xfe78,0xfecb,0x20,0xfe8f,0x670,0xfeae,0x670,0xfecb,
2793         0x20,0xfe8f,0x653,0xfeae,0x653,0xfecb,0x20,0xfe8f,0x654,0xfeae,0x654,0xfecb,0x20,
2794         0xfe8f,0x655,0xfeae,0x655,0xfecb,0x20
2795     };
2796
2797     UChar dest[43];
2798     UErrorCode errorCode;
2799     int32_t length;
2800
2801     errorCode=U_ZERO_ERROR;
2802
2803     length=u_shapeArabic(source, LENGTHOF(source),
2804                          dest, LENGTHOF(dest),
2805                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_NEAR|
2806                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2807                          &errorCode);
2808
2809     if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_near) || memcmp(dest, shape_near, length*U_SIZEOF_UCHAR)!=0) {
2810         log_err("failure in u_shapeArabic(TASHKEEL shape_near)\n");
2811     }
2812
2813     errorCode=U_ZERO_ERROR;
2814
2815     length=u_shapeArabic(source, LENGTHOF(source),
2816                          dest, LENGTHOF(dest),
2817                          U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_FIXED_SPACES_NEAR|
2818                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2819                          &errorCode);
2820
2821     if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_excepttashkeel_near) || memcmp(dest, shape_excepttashkeel_near, length*U_SIZEOF_UCHAR)!=0) {
2822         log_err("failure in u_shapeArabic(TASHKEEL shape_excepttashkeel_near)\n");
2823     }
2824 }
2825
2826 static void
2827 doLOGICALArabicDeShapingTest(void) {
2828     static const UChar
2829     source[]={
2830         0x0020,0x0020,0x0020,0xFE8D,0xFEF5,0x0020,0xFEE5,0x0020,0xFE8D,0xFEF7,0x0020,
2831         0xFED7,0xFEFC,0x0020,0xFEE1,0x0020,0xFE8D,0xFEDF,0xFECC,0xFEAE,0xFE91,0xFEF4,
2832         0xFE94,0x0020,0xFE8D,0xFEDF,0xFEA4,0xFEAE,0xFE93,0x0020,0x0020,0x0020,0x0020
2833     }, unshape_near[]={
2834         0x20,0x20,0x20,0x627,0x644,0x622,0x646,0x20,0x627,0x644,0x623,0x642,0x644,0x627,
2835         0x645,0x20,0x627,0x644,0x639,0x631,0x628,0x64a,0x629,0x20,0x627,0x644,0x62d,0x631,
2836         0x629,0x20,0x20,0x20,0x20
2837     }, unshape_at_end[]={
2838         0x20,0x20,0x20,0x627,0x644,0x622,0x20,0x646,0x20,0x627,0x644,0x623,0x20,0x642,
2839         0x644,0x627,0x20,0x645,0x20,0x627,0x644,0x639,0x631,0x628,0x64a,0x629,0x20,0x627,
2840         0x644,0x62d,0x631,0x629,0x20
2841     }, unshape_at_begin[]={
2842         0x627,0x644,0x622,0x20,0x646,0x20,0x627,0x644,0x623,0x20,0x642,0x644,0x627,0x20,
2843         0x645,0x20,0x627,0x644,0x639,0x631,0x628,0x64a,0x629,0x20,0x627,0x644,0x62d,0x631,
2844         0x629,0x20,0x20,0x20,0x20
2845     }, unshape_grow_shrink[]={
2846         0x20,0x20,0x20,0x627,0x644,0x622,0x20,0x646,0x20,0x627,0x644,0x623,0x20,0x642,
2847         0x644,0x627,0x20,0x645,0x20,0x627,0x644,0x639,0x631,0x628,0x64a,0x629,0x20,0x627,
2848         0x644,0x62d,0x631,0x629,0x20,0x20,0x20,0x20
2849     };
2850
2851     UChar dest[36];
2852     UErrorCode errorCode;
2853     int32_t length;
2854
2855     errorCode=U_ZERO_ERROR;
2856
2857     length=u_shapeArabic(source, LENGTHOF(source),
2858                          dest, LENGTHOF(dest),
2859                          U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_FIXED_SPACES_NEAR|
2860                          U_SHAPE_TEXT_DIRECTION_LOGICAL,
2861                          &errorCode);
2862
2863     if(U_FAILURE(errorCode) || length!=LENGTHOF(unshape_near) || memcmp(dest, unshape_near, length*U_SIZEOF_UCHAR)!=0) {
2864         log_err("failure in u_shapeArabic(unshape_near)\n");
2865     }
2866
2867     errorCode=U_ZERO_ERROR;
2868
2869     length=u_shapeArabic(source, LENGTHOF(source),
2870                          dest, LENGTHOF(dest),
2871                          U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_END|
2872                          U_SHAPE_TEXT_DIRECTION_LOGICAL,
2873                          &errorCode);
2874
2875     if(U_FAILURE(errorCode) || length!=LENGTHOF(unshape_at_end) || memcmp(dest, unshape_at_end, length*U_SIZEOF_UCHAR)!=0) {
2876         log_err("failure in u_shapeArabic(unshape_at_end)\n");
2877     }
2878
2879     errorCode=U_ZERO_ERROR;
2880
2881     length=u_shapeArabic(source, LENGTHOF(source),
2882                          dest, LENGTHOF(dest),
2883                          U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_BEGINNING|
2884                          U_SHAPE_TEXT_DIRECTION_LOGICAL,
2885                          &errorCode);
2886
2887     if(U_FAILURE(errorCode) || length!=LENGTHOF(unshape_at_begin) || memcmp(dest, unshape_at_begin, length*U_SIZEOF_UCHAR)!=0) {
2888         log_err("failure in u_shapeArabic(unshape_at_begin)\n");
2889     }
2890
2891     errorCode=U_ZERO_ERROR;
2892
2893     length=u_shapeArabic(source, LENGTHOF(source),
2894                          dest, LENGTHOF(dest),
2895                          U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_GROW_SHRINK|
2896                          U_SHAPE_TEXT_DIRECTION_LOGICAL,
2897                          &errorCode);
2898
2899     if(U_FAILURE(errorCode) || memcmp(dest, unshape_grow_shrink, length*U_SIZEOF_UCHAR)!=0) {
2900         log_err("failure in u_shapeArabic(unshape_grow_shrink)\n");
2901     }
2902
2903 }
2904
2905 static void
2906 doTailTest(void) {
2907   static const UChar src[] = { 0x0020, 0x0633, 0 };
2908   static const UChar dst_old[] = { 0xFEB1, 0x200B,0 };
2909   static const UChar dst_new[] = { 0xFEB1, 0xFE73,0 };
2910   UChar dst[3] = { 0x0000, 0x0000,0 };
2911   int32_t length;
2912   UErrorCode status;
2913
2914   log_verbose("SRC: U+%04X U+%04X\n", src[0],src[1]);
2915
2916   log_verbose("Trying old tail\n");
2917   status = U_ZERO_ERROR;
2918   length = u_shapeArabic(src, -1, dst, LENGTHOF(dst),
2919                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR, &status);
2920   if(U_FAILURE(status)) {
2921     log_err("Fail: status %s\n", u_errorName(status));
2922   } else if(length!=2) {
2923     log_err("Fail: len %d expected 3\n", length);
2924   } else if(u_strncmp(dst,dst_old,LENGTHOF(dst))) {
2925     log_err("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
2926             dst[0],dst[1],dst_old[0],dst_old[1]);
2927   } else {
2928     log_verbose("OK:  U+%04X U+%04X len %d err %s\n",
2929             dst[0],dst[1],length,u_errorName(status));
2930   }
2931
2932
2933   log_verbose("Trying new tail\n");
2934   status = U_ZERO_ERROR;
2935   length = u_shapeArabic(src, -1, dst, LENGTHOF(dst),
2936                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR|U_SHAPE_TAIL_NEW_UNICODE, &status);
2937   if(U_FAILURE(status)) {
2938     log_err("Fail: status %s\n", u_errorName(status));
2939   } else if(length!=2) {
2940     log_err("Fail: len %d expected 3\n", length);
2941   } else if(u_strncmp(dst,dst_new,LENGTHOF(dst))) {
2942     log_err("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
2943             dst[0],dst[1],dst_new[0],dst_new[1]);
2944   } else {
2945     log_verbose("OK:  U+%04X U+%04X len %d err %s\n",
2946             dst[0],dst[1],length,u_errorName(status));
2947   }
2948 }
2949
2950 static void
2951 doArabicShapingTestForBug5421(void) {
2952     static const UChar
2953     persian_letters_source[]={
2954         0x0020, 0x0698, 0x067E, 0x0686, 0x06AF, 0x0020
2955     }, persian_letters[]={
2956         0x0020, 0xFB8B, 0xFB59, 0xFB7D, 0xFB94, 0x0020
2957     }, tashkeel_aggregation_source[]={
2958         0x0020, 0x0628, 0x0651, 0x064E, 0x062A, 0x0631, 0x0645, 0x0020,
2959         0x0628, 0x064E, 0x0651, 0x062A, 0x0631, 0x0645, 0x0020
2960     }, tashkeel_aggregation[]={
2961         0x0020, 0xFE90, 0xFC60, 0xFE97, 0xFEAE, 0xFEE3,
2962         0x0020, 0xFE90, 0xFC60, 0xFE97, 0xFEAE, 0xFEE3, 0x0020
2963     }, untouched_presentation_source[]={
2964         0x0020 ,0x0627, 0xfe90,0x0020
2965     }, untouched_presentation[]={
2966         0x0020,0xfe8D, 0xfe90,0x0020
2967     }, untouched_presentation_r_source[]={
2968         0x0020 ,0xfe90, 0x0627, 0x0020
2969     }, untouched_presentation_r[]={
2970         0x0020, 0xfe90,0xfe8D,0x0020
2971     };
2972
2973     UChar dest[38];
2974     UErrorCode errorCode;
2975     int32_t length;
2976
2977     errorCode=U_ZERO_ERROR;
2978
2979     length=u_shapeArabic(persian_letters_source, LENGTHOF(persian_letters_source),
2980                          dest, LENGTHOF(dest),
2981                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2982                          &errorCode);
2983
2984     if(U_FAILURE(errorCode) || length!=LENGTHOF(persian_letters) || memcmp(dest, persian_letters, length*U_SIZEOF_UCHAR)!=0) {
2985         log_err("failure in u_shapeArabic(persian_letters)\n");
2986     }
2987
2988     errorCode=U_ZERO_ERROR;
2989
2990     length=u_shapeArabic(tashkeel_aggregation_source, LENGTHOF(tashkeel_aggregation_source),
2991                          dest, LENGTHOF(dest),
2992                          U_SHAPE_AGGREGATE_TASHKEEL|U_SHAPE_PRESERVE_PRESENTATION|
2993                          U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
2994                          &errorCode);
2995
2996     if(U_FAILURE(errorCode) || length!=LENGTHOF(tashkeel_aggregation) || memcmp(dest, tashkeel_aggregation, length*U_SIZEOF_UCHAR)!=0) {
2997         log_err("failure in u_shapeArabic(tashkeel_aggregation)\n");
2998     }
2999
3000     errorCode=U_ZERO_ERROR;
3001
3002     length=u_shapeArabic(untouched_presentation_source, LENGTHOF(untouched_presentation_source),
3003                          dest, LENGTHOF(dest),
3004                          U_SHAPE_PRESERVE_PRESENTATION|
3005                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
3006                          &errorCode);
3007
3008     if(U_FAILURE(errorCode) || length!=LENGTHOF(untouched_presentation) || memcmp(dest, untouched_presentation, length*U_SIZEOF_UCHAR)!=0) {
3009         log_err("failure in u_shapeArabic(untouched_presentation)\n");
3010     }
3011
3012     errorCode=U_ZERO_ERROR;
3013
3014     length=u_shapeArabic(untouched_presentation_r_source, LENGTHOF(untouched_presentation_r_source),
3015                          dest, LENGTHOF(dest),
3016                          U_SHAPE_PRESERVE_PRESENTATION|
3017                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_TEXT_DIRECTION_LOGICAL,
3018                          &errorCode);
3019
3020     if(U_FAILURE(errorCode) || length!=LENGTHOF(untouched_presentation_r) || memcmp(dest, untouched_presentation_r, length*U_SIZEOF_UCHAR)!=0) {
3021         log_err("failure in u_shapeArabic(untouched_presentation_r)\n");
3022     }
3023 }
3024
3025 static void
3026 doArabicShapingTestForBug8703(void) {
3027     static const UChar
3028     letters_source1[]={
3029         0x0634,0x0651,0x0645,0x0652,0x0633
3030     }, letters_source2[]={
3031         0x0634,0x0651,0x0645,0x0652,0x0633
3032     }, letters_source3[]={
3033        0x0634,0x0651,0x0645,0x0652,0x0633
3034     }, letters_source4[]={
3035         0x0634,0x0651,0x0645,0x0652,0x0633
3036     }, letters_source5[]={
3037         0x0633,0x0652,0x0645,0x0651,0x0634
3038     }, letters_source6[]={
3039         0x0633,0x0652,0x0645,0x0651,0x0634
3040     }, letters_source7[]={
3041         0x0633,0x0652,0x0645,0x0651,0x0634
3042     }, letters_source8[]={
3043         0x0633,0x0652,0x0645,0x0651,0x0634
3044     }, letters_dest1[]={
3045         0x0020,0xFEB7,0xFE7D,0xFEE4,0xFEB2
3046     }, letters_dest2[]={
3047         0xFEB7,0xFE7D,0xFEE4,0xFEB2,0x0020
3048     }, letters_dest3[]={
3049         0xFEB7,0xFE7D,0xFEE4,0xFEB2
3050     }, letters_dest4[]={
3051         0xFEB7,0xFE7D,0xFEE4,0x0640,0xFEB2
3052     }, letters_dest5[]={
3053         0x0020,0xFEB2,0xFEE4,0xFE7D,0xFEB7
3054     }, letters_dest6[]={
3055         0xFEB2,0xFEE4,0xFE7D,0xFEB7,0x0020
3056     }, letters_dest7[]={
3057         0xFEB2,0xFEE4,0xFE7D,0xFEB7
3058     }, letters_dest8[]={
3059         0xFEB2,0x0640,0xFEE4,0xFE7D,0xFEB7
3060     };
3061
3062     UChar dest[20];
3063     UErrorCode errorCode;
3064     int32_t length;
3065
3066     errorCode=U_ZERO_ERROR;
3067
3068     length=u_shapeArabic(letters_source1, LENGTHOF(letters_source1),
3069                          dest, LENGTHOF(dest),
3070                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_BEGIN | U_SHAPE_LETTERS_SHAPE,
3071                          &errorCode);
3072
3073     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest1) || memcmp(dest, letters_dest1, length*U_SIZEOF_UCHAR)!=0) {
3074         log_err("failure in u_shapeArabic(letters_source1)\n");
3075     }
3076
3077     errorCode=U_ZERO_ERROR;
3078
3079     length=u_shapeArabic(letters_source2, LENGTHOF(letters_source2),
3080                          dest, LENGTHOF(dest),
3081                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_END | U_SHAPE_LETTERS_SHAPE,
3082                          &errorCode);
3083
3084     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest2) || memcmp(dest, letters_dest2, length*U_SIZEOF_UCHAR)!=0) {
3085         log_err("failure in u_shapeArabic(letters_source2)\n");
3086     }
3087
3088     errorCode=U_ZERO_ERROR;
3089
3090     length=u_shapeArabic(letters_source3, LENGTHOF(letters_source3),
3091                          dest, LENGTHOF(dest),
3092                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_RESIZE | U_SHAPE_LETTERS_SHAPE,
3093                          &errorCode);
3094
3095     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest3) || memcmp(dest, letters_dest3, length*U_SIZEOF_UCHAR)!=0) {
3096         log_err("failure in u_shapeArabic(letters_source3)\n");
3097     }
3098
3099     errorCode=U_ZERO_ERROR;
3100
3101     length=u_shapeArabic(letters_source4, LENGTHOF(letters_source4),
3102                          dest, LENGTHOF(dest),
3103                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_REPLACE_BY_TATWEEL | U_SHAPE_LETTERS_SHAPE,
3104                          &errorCode);
3105
3106     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest4) || memcmp(dest, letters_dest4, length*U_SIZEOF_UCHAR)!=0) {
3107         log_err("failure in u_shapeArabic(letters_source4)\n");
3108     }
3109
3110     errorCode=U_ZERO_ERROR;
3111
3112     length=u_shapeArabic(letters_source5, LENGTHOF(letters_source5),
3113                          dest, LENGTHOF(dest),
3114                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_BEGIN | U_SHAPE_LETTERS_SHAPE,
3115                          &errorCode);
3116
3117     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest5) || memcmp(dest, letters_dest5, length*U_SIZEOF_UCHAR)!=0) {
3118         log_err("failure in u_shapeArabic(letters_source5)\n");
3119     }
3120
3121     errorCode=U_ZERO_ERROR;
3122
3123     length=u_shapeArabic(letters_source6, LENGTHOF(letters_source6),
3124                          dest, LENGTHOF(dest),
3125                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_END | U_SHAPE_LETTERS_SHAPE,
3126                          &errorCode);
3127
3128     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest6) || memcmp(dest, letters_dest6, length*U_SIZEOF_UCHAR)!=0) {
3129         log_err("failure in u_shapeArabic(letters_source6)\n");
3130     }
3131
3132     errorCode=U_ZERO_ERROR;
3133
3134     length=u_shapeArabic(letters_source7, LENGTHOF(letters_source7),
3135                          dest, LENGTHOF(dest),
3136                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_RESIZE | U_SHAPE_LETTERS_SHAPE,
3137                          &errorCode);
3138
3139     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest7) || memcmp(dest, letters_dest7, length*U_SIZEOF_UCHAR)!=0) {
3140         log_err("failure in u_shapeArabic(letters_source7)\n");
3141     }
3142
3143     errorCode=U_ZERO_ERROR;
3144
3145     length=u_shapeArabic(letters_source8, LENGTHOF(letters_source8),
3146                          dest, LENGTHOF(dest),
3147                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_REPLACE_BY_TATWEEL | U_SHAPE_LETTERS_SHAPE,
3148                          &errorCode);
3149
3150     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest8) || memcmp(dest, letters_dest8, length*U_SIZEOF_UCHAR)!=0) {
3151         log_err("failure in u_shapeArabic(letters_source8)\n");
3152     }
3153 }
3154
3155 static void
3156 doArabicShapingTestForBug9024(void) {
3157     static const UChar
3158     letters_source1[]={  /* Arabic mathematical Symbols 0x1EE00 - 0x1EE1B */
3159         0xD83B, 0xDE00, 0xD83B, 0xDE01, 0xD83B, 0xDE02, 0xD83B, 0xDE03, 0x20,
3160         0xD83B, 0xDE24, 0xD83B, 0xDE05, 0xD83B, 0xDE06, 0x20,
3161         0xD83B, 0xDE07, 0xD83B, 0xDE08, 0xD83B, 0xDE09, 0x20,
3162         0xD83B, 0xDE0A, 0xD83B, 0xDE0B, 0xD83B, 0xDE0C, 0xD83B, 0xDE0D, 0x20,
3163         0xD83B, 0xDE0E, 0xD83B, 0xDE0F, 0xD83B, 0xDE10, 0xD83B, 0xDE11, 0x20,
3164         0xD83B, 0xDE12, 0xD83B, 0xDE13, 0xD83B, 0xDE14, 0xD83B, 0xDE15, 0x20,
3165         0xD83B, 0xDE16, 0xD83B, 0xDE17, 0xD83B, 0xDE18, 0x20,
3166         0xD83B, 0xDE19, 0xD83B, 0xDE1A, 0xD83B, 0xDE1B
3167     }, letters_source2[]={/* Arabic mathematical Symbols - Looped Symbols, 0x1EE80 - 0x1EE9B */
3168         0xD83B, 0xDE80, 0xD83B, 0xDE81, 0xD83B, 0xDE82, 0xD83B, 0xDE83, 0x20,
3169         0xD83B, 0xDE84, 0xD83B, 0xDE85, 0xD83B, 0xDE86, 0x20,
3170         0xD83B, 0xDE87, 0xD83B, 0xDE88, 0xD83B, 0xDE89, 0x20,
3171         0xD83B, 0xDE8B, 0xD83B, 0xDE8C, 0xD83B, 0xDE8D, 0x20,
3172         0xD83B, 0xDE8E, 0xD83B, 0xDE8F, 0xD83B, 0xDE90, 0xD83B, 0xDE91, 0x20,
3173         0xD83B, 0xDE92, 0xD83B, 0xDE93, 0xD83B, 0xDE94, 0xD83B, 0xDE95, 0x20,
3174         0xD83B, 0xDE96, 0xD83B, 0xDE97, 0xD83B, 0xDE98, 0x20,
3175         0xD83B, 0xDE99, 0xD83B, 0xDE9A, 0xD83B, 0xDE9B
3176     }, letters_source3[]={/* Arabic mathematical Symbols - Double-struck Symbols, 0x1EEA1 - 0x1EEBB */
3177         0xD83B, 0xDEA1, 0xD83B, 0xDEA2, 0xD83B, 0xDEA3, 0x20,
3178         0xD83B, 0xDEA5, 0xD83B, 0xDEA6, 0x20,
3179         0xD83B, 0xDEA7, 0xD83B, 0xDEA8, 0xD83B, 0xDEA9, 0x20,
3180         0xD83B, 0xDEAB, 0xD83B, 0xDEAC, 0xD83B, 0xDEAD, 0x20,
3181         0xD83B, 0xDEAE, 0xD83B, 0xDEAF, 0xD83B, 0xDEB0, 0xD83B, 0xDEB1, 0x20,
3182         0xD83B, 0xDEB2, 0xD83B, 0xDEB3, 0xD83B, 0xDEB4, 0xD83B, 0xDEB5, 0x20,
3183         0xD83B, 0xDEB6, 0xD83B, 0xDEB7, 0xD83B, 0xDEB8, 0x20,
3184         0xD83B, 0xDEB9, 0xD83B, 0xDEBA, 0xD83B, 0xDEBB
3185     }, letters_source4[]={/* Arabic mathematical Symbols - Initial Symbols, 0x1EE21 - 0x1EE3B */
3186         0xD83B, 0xDE21, 0xD83B, 0xDE22, 0x20,
3187         0xD83B, 0xDE27, 0xD83B, 0xDE29, 0x20,
3188         0xD83B, 0xDE2A, 0xD83B, 0xDE2B, 0xD83B, 0xDE2C, 0xD83B, 0xDE2D, 0x20,
3189         0xD83B, 0xDE2E, 0xD83B, 0xDE2F, 0xD83B, 0xDE30, 0xD83B, 0xDE31, 0x20,
3190         0xD83B, 0xDE32, 0xD83B, 0xDE34, 0xD83B, 0xDE35, 0x20,
3191         0xD83B, 0xDE36, 0xD83B, 0xDE37, 0x20,
3192         0xD83B, 0xDE39, 0xD83B, 0xDE3B
3193     }, letters_source5[]={/* Arabic mathematical Symbols - Tailed Symbols */
3194         0xD83B, 0xDE42, 0xD83B, 0xDE47, 0xD83B, 0xDE49, 0xD83B, 0xDE4B, 0x20,
3195         0xD83B, 0xDE4D, 0xD83B, 0xDE4E, 0xD83B, 0xDE4F, 0x20,
3196         0xD83B, 0xDE51, 0xD83B, 0xDE52, 0xD83B, 0xDE54, 0xD83B, 0xDE57, 0x20,
3197         0xD83B, 0xDE59, 0xD83B, 0xDE5B, 0xD83B, 0xDE5D, 0xD83B, 0xDE5F
3198     }, letters_source6[]={/* Arabic mathematical Symbols - Stretched Symbols with 06 range */
3199         0xD83B, 0xDE21, 0x0633, 0xD83B, 0xDE62, 0x0647
3200     }, letters_dest1[]={
3201         0xD83B, 0xDE00, 0xD83B, 0xDE01, 0xD83B, 0xDE02, 0xD83B, 0xDE03, 0x20,
3202         0xD83B, 0xDE24, 0xD83B, 0xDE05, 0xD83B, 0xDE06, 0x20,
3203         0xD83B, 0xDE07, 0xD83B, 0xDE08, 0xD83B, 0xDE09, 0x20,
3204         0xD83B, 0xDE0A, 0xD83B, 0xDE0B, 0xD83B, 0xDE0C, 0xD83B, 0xDE0D, 0x20,
3205         0xD83B, 0xDE0E, 0xD83B, 0xDE0F, 0xD83B, 0xDE10, 0xD83B, 0xDE11, 0x20,
3206         0xD83B, 0xDE12, 0xD83B, 0xDE13, 0xD83B, 0xDE14, 0xD83B, 0xDE15, 0x20,
3207         0xD83B, 0xDE16, 0xD83B, 0xDE17, 0xD83B, 0xDE18, 0x20,
3208         0xD83B, 0xDE19, 0xD83B, 0xDE1A, 0xD83B, 0xDE1B
3209     }, letters_dest2[]={
3210         0xD83B, 0xDE80, 0xD83B, 0xDE81, 0xD83B, 0xDE82, 0xD83B, 0xDE83, 0x20,
3211         0xD83B, 0xDE84, 0xD83B, 0xDE85, 0xD83B, 0xDE86, 0x20,
3212         0xD83B, 0xDE87, 0xD83B, 0xDE88, 0xD83B, 0xDE89, 0x20,
3213         0xD83B, 0xDE8B, 0xD83B, 0xDE8C, 0xD83B, 0xDE8D, 0x20,
3214         0xD83B, 0xDE8E, 0xD83B, 0xDE8F, 0xD83B, 0xDE90, 0xD83B, 0xDE91, 0x20,
3215         0xD83B, 0xDE92, 0xD83B, 0xDE93, 0xD83B, 0xDE94, 0xD83B, 0xDE95, 0x20,
3216         0xD83B, 0xDE96, 0xD83B, 0xDE97, 0xD83B, 0xDE98, 0x20,
3217         0xD83B, 0xDE99, 0xD83B, 0xDE9A, 0xD83B, 0xDE9B
3218     }, letters_dest3[]={
3219         0xD83B, 0xDEA1, 0xD83B, 0xDEA2, 0xD83B, 0xDEA3, 0x20,
3220         0xD83B, 0xDEA5, 0xD83B, 0xDEA6, 0x20,
3221         0xD83B, 0xDEA7, 0xD83B, 0xDEA8, 0xD83B, 0xDEA9, 0x20,
3222         0xD83B, 0xDEAB, 0xD83B, 0xDEAC, 0xD83B, 0xDEAD, 0x20,
3223         0xD83B, 0xDEAE, 0xD83B, 0xDEAF, 0xD83B, 0xDEB0, 0xD83B, 0xDEB1, 0x20,
3224         0xD83B, 0xDEB2, 0xD83B, 0xDEB3, 0xD83B, 0xDEB4, 0xD83B, 0xDEB5, 0x20,
3225         0xD83B, 0xDEB6, 0xD83B, 0xDEB7, 0xD83B, 0xDEB8, 0x20,
3226         0xD83B, 0xDEB9, 0xD83B, 0xDEBA, 0xD83B, 0xDEBB
3227     }, letters_dest4[]={
3228         0xD83B, 0xDE21, 0xD83B, 0xDE22, 0x20,
3229         0xD83B, 0xDE27, 0xD83B, 0xDE29, 0x20,
3230         0xD83B, 0xDE2A, 0xD83B, 0xDE2B, 0xD83B, 0xDE2C, 0xD83B, 0xDE2D, 0x20,
3231         0xD83B, 0xDE2E, 0xD83B, 0xDE2F, 0xD83B, 0xDE30, 0xD83B, 0xDE31, 0x20,
3232         0xD83B, 0xDE32, 0xD83B, 0xDE34, 0xD83B, 0xDE35, 0x20,
3233         0xD83B, 0xDE36, 0xD83B, 0xDE37, 0x20,
3234         0xD83B, 0xDE39, 0xD83B, 0xDE3B
3235     }, letters_dest5[]={
3236         0xD83B, 0xDE42, 0xD83B, 0xDE47, 0xD83B, 0xDE49, 0xD83B, 0xDE4B, 0x20,
3237         0xD83B, 0xDE4D, 0xD83B, 0xDE4E, 0xD83B, 0xDE4F, 0x20,
3238         0xD83B, 0xDE51, 0xD83B, 0xDE52, 0xD83B, 0xDE54, 0xD83B, 0xDE57, 0x20,
3239         0xD83B, 0xDE59, 0xD83B, 0xDE5B, 0xD83B, 0xDE5D, 0xD83B, 0xDE5F
3240     }, letters_dest6[]={
3241         0xD83B, 0xDE21, 0xFEB1, 0xD83B, 0xDE62, 0xFEE9
3242     };
3243
3244     UChar dest[MAXLEN];
3245     UErrorCode errorCode;
3246     int32_t length;
3247
3248     errorCode=U_ZERO_ERROR;
3249
3250     length=u_shapeArabic(letters_source1, LENGTHOF(letters_source1),
3251                          dest, LENGTHOF(dest),
3252                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_BEGIN | U_SHAPE_LETTERS_SHAPE,
3253                          &errorCode);
3254
3255     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest1) || memcmp(dest, letters_dest1, length*U_SIZEOF_UCHAR)!=0) {
3256         log_err("failure in u_shapeArabic(letters_source1)\n");
3257     }
3258
3259     errorCode=U_ZERO_ERROR;
3260
3261     length=u_shapeArabic(letters_source2, LENGTHOF(letters_source2),
3262                          dest, LENGTHOF(dest),
3263                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_END | U_SHAPE_LETTERS_SHAPE,
3264                          &errorCode);
3265
3266     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest2) || memcmp(dest, letters_dest2, length*U_SIZEOF_UCHAR)!=0) {
3267         log_err("failure in u_shapeArabic(letters_source2)\n");
3268     }
3269
3270     errorCode=U_ZERO_ERROR;
3271
3272     length=u_shapeArabic(letters_source3, LENGTHOF(letters_source3),
3273                          dest, LENGTHOF(dest),
3274                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_RESIZE | U_SHAPE_LETTERS_SHAPE,
3275                          &errorCode);
3276
3277     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest3) || memcmp(dest, letters_dest3, length*U_SIZEOF_UCHAR)!=0) {
3278         log_err("failure in u_shapeArabic(letters_source3)\n");
3279     }
3280
3281     errorCode=U_ZERO_ERROR;
3282
3283     length=u_shapeArabic(letters_source4, LENGTHOF(letters_source4),
3284                          dest, LENGTHOF(dest),
3285                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_REPLACE_BY_TATWEEL | U_SHAPE_LETTERS_SHAPE,
3286                          &errorCode);
3287
3288     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest4) || memcmp(dest, letters_dest4, length*U_SIZEOF_UCHAR)!=0) {
3289         log_err("failure in u_shapeArabic(letters_source4)\n");
3290     }
3291
3292     errorCode=U_ZERO_ERROR;
3293
3294     length=u_shapeArabic(letters_source5, LENGTHOF(letters_source5),
3295                          dest, LENGTHOF(dest),
3296                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_BEGIN | U_SHAPE_LETTERS_SHAPE,
3297                          &errorCode);
3298
3299     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest5) || memcmp(dest, letters_dest5, length*U_SIZEOF_UCHAR)!=0) {
3300         log_err("failure in u_shapeArabic(letters_source5)\n");
3301     }
3302
3303     errorCode=U_ZERO_ERROR;
3304
3305     length=u_shapeArabic(letters_source6, LENGTHOF(letters_source6),
3306                          dest, LENGTHOF(dest),
3307                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_END | U_SHAPE_LETTERS_SHAPE,
3308                          &errorCode);
3309
3310     if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest6) || memcmp(dest, letters_dest6, length*U_SIZEOF_UCHAR)!=0) {
3311         log_err("failure in u_shapeArabic(letters_source6)\n");
3312     }
3313
3314 }
3315
3316 /* helpers ------------------------------------------------------------------ */
3317
3318 static void initCharFromDirProps(void) {
3319     static const UVersionInfo ucd401={ 4, 0, 1, 0 };
3320     static UVersionInfo ucdVersion={ 0, 0, 0, 0 };
3321
3322     /* lazy initialization */
3323     if(ucdVersion[0]>0) {
3324         return;
3325     }
3326
3327     u_getUnicodeVersion(ucdVersion);
3328     if(memcmp(ucdVersion, ucd401, sizeof(UVersionInfo))>=0) {
3329         /* Unicode 4.0.1 changes bidi classes for +-/ */
3330         charFromDirProp[U_EUROPEAN_NUMBER_SEPARATOR]=0x2b; /* change ES character from / to + */
3331     }
3332 }
3333
3334 /* return a string with characters according to the desired directional properties */
3335 static UChar *
3336 getStringFromDirProps(const uint8_t *dirProps, int32_t length, UChar *buffer) {
3337     int32_t i;
3338
3339     initCharFromDirProps();
3340
3341     /* this part would have to be modified for UTF-x */
3342     for(i=0; i<length; ++i) {
3343         buffer[i]=charFromDirProp[dirProps[i]];
3344     }
3345     buffer[length]=0;
3346     return buffer;
3347 }
3348
3349 static void printUnicode(const UChar *s, int32_t length, const UBiDiLevel *levels) {
3350     int32_t i;
3351
3352     log_verbose("{ ");
3353     for(i=0; i<length; ++i) {
3354         if(levels!=NULL) {
3355             log_verbose("%4x.%u  ", s[i], levels[i]);
3356         } else {
3357             log_verbose("%4x    ", s[i]);
3358         }
3359     }
3360     log_verbose(" }");
3361 }
3362
3363 /* new BIDI API */
3364
3365 /* Reordering Mode BiDi --------------------------------------------------------- */
3366
3367 static const UBiDiLevel paraLevels[] = { UBIDI_LTR, UBIDI_RTL };
3368
3369 static UBool
3370 assertSuccessful(const char* message, UErrorCode* rc) {
3371     if (rc != NULL && U_FAILURE(*rc)) {
3372         log_err("%s() failed with error %s.\n", message, myErrorName(*rc));
3373         return FALSE;
3374     }
3375     return TRUE;
3376 }
3377
3378 static UBool
3379 assertStringsEqual(const char* expected, const char* actual, const char* src,
3380                    const char* mode, const char* option, UBiDi* pBiDi) {
3381     if (uprv_strcmp(expected, actual)) {
3382         char formatChars[MAXLEN];
3383         log_err("\nActual and expected output mismatch.\n"
3384             "%20s %s\n%20s %s\n%20s %s\n%20s %s\n%20s %d %s\n%20s %u\n%20s %d %s\n",
3385             "Input:", src,
3386             "Actual output:", actual,
3387             "Expected output:", expected,
3388             "Levels:", formatLevels(pBiDi, formatChars),
3389             "Reordering mode:", ubidi_getReorderingMode(pBiDi), mode,
3390             "Paragraph level:", ubidi_getParaLevel(pBiDi),
3391             "Reordering option:", ubidi_getReorderingOptions(pBiDi), option);
3392         return FALSE;
3393     }
3394     return TRUE;
3395 }
3396
3397 static UBiDi*
3398 getBiDiObject(void) {
3399     UBiDi* pBiDi = ubidi_open();
3400     if (pBiDi == NULL) {
3401         log_err("Unable to allocate a UBiDi object. Tests are skipped.\n");
3402     }
3403     return pBiDi;
3404 }
3405
3406 #define MAKE_ITEMS(val) val, #val
3407
3408 static const struct {
3409     UBiDiReorderingMode value;
3410     const char* description;
3411 }
3412 modes[] = {
3413     { MAKE_ITEMS(UBIDI_REORDER_GROUP_NUMBERS_WITH_R) },
3414     { MAKE_ITEMS(UBIDI_REORDER_INVERSE_LIKE_DIRECT) },
3415     { MAKE_ITEMS(UBIDI_REORDER_NUMBERS_SPECIAL) },
3416     { MAKE_ITEMS(UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL) },
3417     { MAKE_ITEMS(UBIDI_REORDER_INVERSE_NUMBERS_AS_L) }
3418 };
3419 static const struct {
3420     uint32_t value;
3421     const char* description;
3422 }
3423 options[] = {
3424     { MAKE_ITEMS(UBIDI_OPTION_INSERT_MARKS) },
3425     { MAKE_ITEMS(0) }
3426 };
3427
3428 #define TC_COUNT                LENGTHOF(textIn)
3429 #define MODES_COUNT             LENGTHOF(modes)
3430 #define OPTIONS_COUNT           LENGTHOF(options)
3431 #define LEVELS_COUNT            LENGTHOF(paraLevels)
3432
3433 static const char* const textIn[] = {
3434 /* (0) 123 */
3435     "123",
3436 /* (1) .123->4.5 */
3437     ".123->4.5",
3438 /* (2) 678 */
3439     "678",
3440 /* (3) .678->8.9 */
3441     ".678->8.9",
3442 /* (4) JIH1.2,3MLK */
3443     "JIH1.2,3MLK",
3444 /* (5) FE.>12-> */
3445     "FE.>12->",
3446 /* (6) JIH.>12->a */
3447     "JIH.>12->a",
3448 /* (7) CBA.>67->89=a */
3449     "CBA.>67->89=a",
3450 /* (8) CBA.123->xyz */
3451     "CBA.123->xyz",
3452 /* (9) .>12->xyz */
3453     ".>12->xyz",
3454 /* (10) a.>67->xyz */
3455     "a.>67->xyz",
3456 /* (11) 123JIH */
3457     "123JIH",
3458 /* (12) 123 JIH */
3459     "123 JIH"
3460 };
3461
3462 static const char* const textOut[] = {
3463 /* TC 0: 123 */
3464     "123",                                                              /* (0) */
3465 /* TC 1: .123->4.5 */
3466     ".123->4.5",                                                        /* (1) */
3467     "4.5<-123.",                                                        /* (2) */
3468 /* TC 2: 678 */
3469     "678",                                                              /* (3) */
3470 /* TC 3: .678->8.9 */
3471     ".8.9<-678",                                                        /* (4) */
3472     "8.9<-678.",                                                        /* (5) */
3473     ".678->8.9",                                                        /* (6) */
3474 /* TC 4: MLK1.2,3JIH */
3475     "KLM1.2,3HIJ",                                                      /* (7) */
3476 /* TC 5: FE.>12-> */
3477     "12<.EF->",                                                         /* (8) */
3478     "<-12<.EF",                                                         /* (9) */
3479     "EF.>@12->",                                                        /* (10) */
3480 /* TC 6: JIH.>12->a */
3481     "12<.HIJ->a",                                                       /* (11) */
3482     "a<-12<.HIJ",                                                       /* (12) */
3483     "HIJ.>@12->a",                                                      /* (13) */
3484     "a&<-12<.HIJ",                                                      /* (14) */
3485 /* TC 7: CBA.>67->89=a */
3486     "ABC.>@67->89=a",                                                   /* (15) */
3487     "a=89<-67<.ABC",                                                    /* (16) */
3488     "a&=89<-67<.ABC",                                                   /* (17) */
3489     "89<-67<.ABC=a",                                                    /* (18) */
3490 /* TC 8: CBA.123->xyz */
3491     "123.ABC->xyz",                                                     /* (19) */
3492     "xyz<-123.ABC",                                                     /* (20) */
3493     "ABC.@123->xyz",                                                    /* (21) */
3494     "xyz&<-123.ABC",                                                    /* (22) */
3495 /* TC 9: .>12->xyz */
3496     ".>12->xyz",                                                        /* (23) */
3497     "xyz<-12<.",                                                        /* (24) */
3498     "xyz&<-12<.",                                                       /* (25) */
3499 /* TC 10: a.>67->xyz */
3500     "a.>67->xyz",                                                       /* (26) */
3501     "a.>@67@->xyz",                                                     /* (27) */
3502     "xyz<-67<.a",                                                       /* (28) */
3503 /* TC 11: 123JIH */
3504     "123HIJ",                                                           /* (29) */
3505     "HIJ123",                                                           /* (30) */
3506 /* TC 12: 123 JIH */
3507     "123 HIJ",                                                          /* (31) */
3508     "HIJ 123",                                                          /* (32) */
3509 };
3510
3511 #define NO                  UBIDI_MAP_NOWHERE
3512 #define MAX_MAP_LENGTH      20
3513
3514 static const int32_t forwardMap[][MAX_MAP_LENGTH] = {
3515 /* TC 0: 123 */
3516     { 0, 1, 2 },                                                        /* (0) */
3517 /* TC 1: .123->4.5 */
3518     { 0, 1, 2, 3, 4, 5, 6, 7, 8 },                                      /* (1) */
3519     { 8, 5, 6, 7, 4, 3, 0, 1, 2 },                                      /* (2) */
3520 /* TC 2: 678 */
3521     { 0, 1, 2 },                                                        /* (3) */
3522 /* TC 3: .678->8.9 */
3523     { 0, 6, 7, 8, 5, 4, 1, 2, 3 },                                      /* (4) */
3524     { 8, 5, 6, 7, 4, 3, 0, 1, 2 },                                      /* (5) */
3525     { 0, 1, 2, 3, 4, 5, 6, 7, 8 },                                      /* (6) */
3526 /* TC 4: MLK1.2,3JIH */
3527     { 10, 9, 8, 3, 4, 5, 6, 7, 2, 1, 0 },                               /* (7) */
3528 /* TC 5: FE.>12-> */
3529     { 5, 4, 3, 2, 0, 1, 6, 7 },                                         /* (8) */
3530     { 7, 6, 5, 4, 2, 3, 1, 0 },                                         /* (9) */
3531     { 1, 0, 2, 3, 5, 6, 7, 8 },                                         /* (10) */
3532 /* TC 6: JIH.>12->a */
3533     { 6, 5, 4, 3, 2, 0, 1, 7, 8, 9 },                                   /* (11) */
3534     { 9, 8, 7, 6, 5, 3, 4, 2, 1, 0 },                                   /* (12) */
3535     { 2, 1, 0, 3, 4, 6, 7, 8, 9, 10 },                                  /* (13) */
3536     { 10, 9, 8, 7, 6, 4, 5, 3, 2, 0 },                                  /* (14) */
3537 /* TC 7: CBA.>67->89=a */
3538     { 2, 1, 0, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13 },                      /* (15) */
3539     { 12, 11, 10, 9, 8, 6, 7, 5, 4, 2, 3, 1, 0 },                       /* (16) */
3540     { 13, 12, 11, 10, 9, 7, 8, 6, 5, 3, 4, 2, 0 },                      /* (17) */
3541     { 10, 9, 8, 7, 6, 4, 5, 3, 2, 0, 1, 11, 12 },                       /* (18) */
3542 /* TC 8: CBA.123->xyz */
3543     { 6, 5, 4, 3, 0, 1, 2, 7, 8, 9, 10, 11 },                           /* (19) */
3544     { 11, 10, 9, 8, 5, 6, 7, 4, 3, 0, 1, 2 },                           /* (20) */
3545     { 2, 1, 0, 3, 5, 6, 7, 8, 9, 10, 11, 12 },                          /* (21) */
3546     { 12, 11, 10, 9, 6, 7, 8, 5, 4, 0, 1, 2 },                          /* (22) */
3547 /* TC 9: .>12->xyz */
3548     { 0, 1, 2, 3, 4, 5, 6, 7, 8 },                                      /* (23) */
3549     { 8, 7, 5, 6, 4, 3, 0, 1, 2 },                                      /* (24) */
3550     { 9, 8, 6, 7, 5, 4, 0, 1, 2 },                                      /* (25) */
3551 /* TC 10: a.>67->xyz */
3552     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },                                   /* (26) */
3553     { 0, 1, 2, 4, 5, 7, 8, 9, 10, 11 },                                 /* (27) */
3554     { 9, 8, 7, 5, 6, 4, 3, 0, 1, 2 },                                   /* (28) */
3555 /* TC 11: 123JIH */
3556     { 0, 1, 2, 5, 4, 3 },                                               /* (29) */
3557     { 3, 4, 5, 2, 1, 0 },                                               /* (30) */
3558 /* TC 12: 123 JIH */
3559     { 0, 1, 2, 3, 6, 5, 4 },                                            /* (31) */
3560     { 4, 5, 6, 3, 2, 1, 0 },                                            /* (32) */
3561 };
3562
3563 static const int32_t inverseMap[][MAX_MAP_LENGTH] = {
3564 /* TC 0: 123 */
3565     { 0, 1, 2 },                                                        /* (0) */
3566 /* TC 1: .123->4.5 */
3567     { 0, 1, 2, 3, 4, 5, 6, 7, 8 },                                      /* (1) */
3568     { 6, 7, 8, 5, 4, 1, 2, 3, 0 },                                      /* (2) */
3569 /* TC 2: 678 */
3570     { 0, 1, 2 },                                                        /* (3) */
3571 /* TC 3: .678->8.9 */
3572     { 0, 6, 7, 8, 5, 4, 1, 2, 3 },                                      /* (4) */
3573     { 6, 7, 8, 5, 4, 1, 2, 3, 0 },                                      /* (5) */
3574     { 0, 1, 2, 3, 4, 5, 6, 7, 8 },                                      /* (6) */
3575 /* TC 4: MLK1.2,3JIH */
3576     { 10, 9, 8, 3, 4, 5, 6, 7, 2, 1, 0 },                               /* (7) */
3577 /* TC 5: FE.>12-> */
3578     { 4, 5, 3, 2, 1, 0, 6, 7 },                                         /* (8) */
3579     { 7, 6, 4, 5, 3, 2, 1, 0 },                                         /* (9) */
3580     { 1, 0, 2, 3, NO, 4, 5, 6, 7 },                                     /* (10) */
3581 /* TC 6: JIH.>12->a */
3582     { 5, 6, 4, 3, 2, 1, 0, 7, 8, 9 },                                   /* (11) */
3583     { 9, 8, 7, 5, 6, 4, 3, 2, 1, 0 },                                   /* (12) */
3584     { 2, 1, 0, 3, 4, NO, 5, 6, 7, 8, 9 },                               /* (13) */
3585     { 9, NO, 8, 7, 5, 6, 4, 3, 2, 1, 0 },                               /* (14) */
3586 /* TC 7: CBA.>67->89=a */
3587     { 2, 1, 0, 3, 4, NO, 5, 6, 7, 8, 9, 10, 11, 12 },                   /* (15) */
3588     { 12, 11, 9, 10, 8, 7, 5, 6, 4, 3, 2, 1, 0 },                       /* (16) */
3589     { 12, NO, 11, 9, 10, 8, 7, 5, 6, 4, 3, 2, 1, 0 },                   /* (17) */
3590     { 9, 10, 8, 7, 5, 6, 4, 3, 2, 1, 0, 11, 12 },                       /* (18) */
3591 /* TC 8: CBA.123->xyz */
3592     { 4, 5, 6, 3, 2, 1, 0, 7, 8, 9, 10, 11 },                           /* (19) */
3593     { 9, 10, 11, 8, 7, 4, 5, 6, 3, 2, 1, 0 },                           /* (20) */
3594     { 2, 1, 0, 3, NO, 4, 5, 6, 7, 8, 9, 10, 11 },                       /* (21) */
3595     { 9, 10, 11, NO, 8, 7, 4, 5, 6, 3, 2, 1, 0 },                       /* (22) */
3596 /* TC 9: .>12->xyz */
3597     { 0, 1, 2, 3, 4, 5, 6, 7, 8 },                                      /* (23) */
3598     { 6, 7, 8, 5, 4, 2, 3, 1, 0 },                                      /* (24) */
3599     { 6, 7, 8, NO, 5, 4, 2, 3, 1, 0 },                                  /* (25) */
3600 /* TC 10: a.>67->xyz */
3601     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },                                   /* (26) */
3602     { 0, 1, 2, NO, 3, 4, NO, 5, 6, 7, 8, 9 },                           /* (27) */
3603     { 7, 8, 9, 6, 5, 3, 4, 2, 1, 0 },                                   /* (28) */
3604 /* TC 11: 123JIH */
3605     { 0, 1, 2, 5, 4, 3 },                                               /* (29) */
3606     { 5, 4, 3, 0, 1, 2 },                                               /* (30) */
3607 /* TC 12: 123 JIH */
3608     { 0, 1, 2, 3, 6, 5, 4 },                                            /* (31) */
3609     { 6, 5, 4, 3, 0, 1, 2 },                                            /* (32) */
3610 };
3611
3612 static const char outIndices[TC_COUNT][MODES_COUNT - 1][OPTIONS_COUNT]
3613             [LEVELS_COUNT] = {
3614     { /* TC 0: 123 */
3615         {{ 0,  0}, { 0,  0}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3616         {{ 0,  0}, { 0,  0}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3617         {{ 0,  0}, { 0,  0}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3618         {{ 0,  0}, { 0,  0}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3619     },
3620     { /* TC 1: .123->4.5 */
3621         {{ 1,  2}, { 1,  2}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3622         {{ 1,  2}, { 1,  2}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3623         {{ 1,  2}, { 1,  2}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3624         {{ 1,  2}, { 1,  2}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3625     },
3626     { /* TC 2: 678 */
3627         {{ 3,  3}, { 3,  3}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3628         {{ 3,  3}, { 3,  3}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3629         {{ 3,  3}, { 3,  3}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3630         {{ 3,  3}, { 3,  3}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3631     },
3632     { /* TC 3: .678->8.9 */
3633         {{ 6,  5}, { 6,  5}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3634         {{ 4,  5}, { 4,  5}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3635         {{ 6,  5}, { 6,  5}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3636         {{ 6,  5}, { 6,  5}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3637     },
3638     { /* TC 4: MLK1.2,3JIH */
3639         {{ 7,  7}, { 7,  7}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3640         {{ 7,  7}, { 7,  7}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3641         {{ 7,  7}, { 7,  7}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3642         {{ 7,  7}, { 7,  7}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3643     },
3644     { /* TC 5: FE.>12-> */
3645         {{ 8,  9}, { 8,  9}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3646         {{10,  9}, { 8,  9}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3647         {{ 8,  9}, { 8,  9}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3648         {{10,  9}, { 8,  9}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3649     },
3650     { /* TC 6: JIH.>12->a */
3651         {{11, 12}, {11, 12}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3652         {{13, 14}, {11, 12}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3653         {{11, 12}, {11, 12}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3654         {{13, 14}, {11, 12}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3655     },
3656     { /* TC 7: CBA.>67->89=a */
3657         {{18, 16}, {18, 16}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3658         {{18, 17}, {18, 16}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3659         {{18, 16}, {18, 16}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3660         {{15, 17}, {18, 16}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3661     },
3662     { /* TC 8: CBA.>124->xyz */
3663         {{19, 20}, {19, 20}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3664         {{21, 22}, {19, 20}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3665         {{19, 20}, {19, 20}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3666         {{21, 22}, {19, 20}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3667     },
3668     { /* TC 9: .>12->xyz */
3669         {{23, 24}, {23, 24}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3670         {{23, 25}, {23, 24}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3671         {{23, 24}, {23, 24}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3672         {{23, 25}, {23, 24}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3673     },
3674     { /* TC 10: a.>67->xyz */
3675         {{26, 26}, {26, 26}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3676         {{26, 27}, {26, 28}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3677         {{26, 28}, {26, 28}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3678         {{26, 27}, {26, 28}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3679     },
3680     { /* TC 11: 124JIH */
3681         {{30, 30}, {30, 30}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3682         {{29, 30}, {29, 30}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3683         {{30, 30}, {30, 30}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3684         {{30, 30}, {30, 30}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3685     },
3686     { /* TC 12: 124 JIH */
3687         {{32, 32}, {32, 32}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3688         {{31, 32}, {31, 32}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3689         {{31, 32}, {31, 32}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3690         {{31, 32}, {31, 32}}  /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3691     }
3692 };
3693
3694 static UBool
3695 assertRoundTrip(UBiDi *pBiDi, int32_t tc, int32_t outIndex, const char *srcChars,
3696                 const char *destChars, const UChar *dest, int32_t destLen,
3697                 int mode, int option, UBiDiLevel level) {
3698
3699     static const char roundtrip[TC_COUNT][MODES_COUNT][OPTIONS_COUNT]
3700                 [LEVELS_COUNT] = {
3701         { /* TC 0: 123 */
3702             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3703             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3704             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3705             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3706             {{ 1,  1}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3707         },
3708         { /* TC 1: .123->4.5 */
3709             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3710             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3711             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3712             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3713             {{ 1,  1}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3714         },
3715         { /* TC 2: 678 */
3716             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3717             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3718             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3719             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3720             {{ 1,  1}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3721         },
3722         { /* TC 3: .678->8.9 */
3723             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3724             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3725             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3726             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3727             {{ 0,  0}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3728         },
3729         { /* TC 4: MLK1.2,3JIH */
3730             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3731             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3732             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3733             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3734             {{ 1,  1}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3735         },
3736         { /* TC 5: FE.>12-> */
3737             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3738             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3739             {{ 0,  1}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3740             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3741             {{ 1,  1}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3742         },
3743         { /* TC 6: JIH.>12->a */
3744             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3745             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3746             {{ 0,  0}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3747             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3748             {{ 1,  1}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3749         },
3750         { /* TC 7: CBA.>67->89=a */
3751             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3752             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3753             {{ 0,  1}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3754             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3755             {{ 0,  0}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3756         },
3757         { /* TC 8: CBA.>123->xyz */
3758             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3759             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3760             {{ 0,  0}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3761             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3762             {{ 1,  1}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3763         },
3764         { /* TC 9: .>12->xyz */
3765             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3766             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3767             {{ 1,  0}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3768             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3769             {{ 1,  1}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3770         },
3771         { /* TC 10: a.>67->xyz */
3772             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3773             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3774             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3775             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3776             {{ 1,  0}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3777         },
3778         { /* TC 11: 123JIH */
3779             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3780             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3781             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3782             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3783             {{ 1,  1}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3784         },
3785         { /* TC 12: 123 JIH */
3786             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_GROUP_NUMBERS_WITH_R */
3787             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_LIKE_DIRECT */
3788             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_NUMBERS_SPECIAL */
3789             {{ 1,  1}, { 1,  1}}, /* UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL */
3790             {{ 1,  1}, { 1,  1}}  /* UBIDI_REORDER_INVERSE_NUMBERS_AS_L */
3791         }
3792     };
3793
3794     #define SET_ROUND_TRIP_MODE(mode) \
3795         ubidi_setReorderingMode(pBiDi, mode); \
3796         desc = #mode; \
3797         break;
3798
3799     UErrorCode rc = U_ZERO_ERROR;
3800     UChar dest2[MAXLEN];
3801     int32_t destLen2;
3802     const char* desc;
3803     char destChars2[MAXLEN];
3804     char destChars3[MAXLEN];
3805
3806     switch (modes[mode].value) {
3807         case UBIDI_REORDER_NUMBERS_SPECIAL:
3808             SET_ROUND_TRIP_MODE(UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL)
3809         case UBIDI_REORDER_GROUP_NUMBERS_WITH_R:
3810             SET_ROUND_TRIP_MODE(UBIDI_REORDER_GROUP_NUMBERS_WITH_R)
3811         case UBIDI_REORDER_RUNS_ONLY:
3812             SET_ROUND_TRIP_MODE(UBIDI_REORDER_RUNS_ONLY)
3813         case UBIDI_REORDER_INVERSE_NUMBERS_AS_L:
3814             SET_ROUND_TRIP_MODE(UBIDI_REORDER_DEFAULT)
3815         case UBIDI_REORDER_INVERSE_LIKE_DIRECT:
3816             SET_ROUND_TRIP_MODE(UBIDI_REORDER_DEFAULT)
3817         case UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL:
3818             SET_ROUND_TRIP_MODE(UBIDI_REORDER_NUMBERS_SPECIAL)
3819         default:
3820             SET_ROUND_TRIP_MODE(UBIDI_REORDER_INVERSE_LIKE_DIRECT)
3821     }
3822     ubidi_setReorderingOptions(pBiDi, UBIDI_OPTION_REMOVE_CONTROLS);
3823
3824     ubidi_setPara(pBiDi, dest, destLen, level, NULL, &rc);
3825     assertSuccessful("ubidi_setPara", &rc);
3826     *dest2 = 0;
3827     destLen2 = ubidi_writeReordered(pBiDi, dest2, MAXLEN, UBIDI_DO_MIRRORING,
3828                                     &rc);
3829     assertSuccessful("ubidi_writeReordered", &rc);
3830
3831     u16ToPseudo(destLen, dest, destChars3);
3832     u16ToPseudo(destLen2, dest2, destChars2);
3833     checkWhatYouCan(pBiDi, destChars3, destChars2);
3834     if (strcmp(srcChars, destChars2)) {
3835         if (roundtrip[tc][mode][option][level]) {
3836             log_err("\nRound trip failed for case=%d mode=%d option=%d.\n"
3837                     "%20s %s\n%20s %s\n%20s %s\n%20s %s\n%20s %s"
3838                     "\n%20s %u\n", tc, mode, option,
3839                     "Original text:", srcChars,
3840                     "Round-tripped text:", destChars2,
3841                     "Intermediate  text:", destChars3,
3842                     "Reordering mode:", modes[mode].description,
3843                     "Reordering option:", options[option].description,
3844                     "Paragraph level:", level);
3845         }
3846         else {
3847             log_verbose("\nExpected round trip failure for case=%d mode=%d option=%d.\n"
3848                     "%20s %s\n%20s %s\n%20s %s\n%20s %s\n%20s %s"
3849                     "\n%20s %u\n", tc, mode, option,
3850                     "Original text:", srcChars,
3851                     "Round-tripped text:", destChars2,
3852                     "Intermediate  text:", destChars3,
3853                     "Reordering mode:", modes[mode].description,
3854                     "Reordering option:", options[option].description,
3855                     "Paragraph level:", level);
3856         }
3857         return FALSE;
3858     }
3859     if (!checkResultLength(pBiDi, destChars, destChars2, destLen2,
3860                            desc, "UBIDI_OPTION_REMOVE_CONTROLS", level)) {
3861         return FALSE;
3862     }
3863     if (outIndex > -1 && !checkMaps(pBiDi, outIndex, srcChars, destChars,
3864                                     desc, "UBIDI_OPTION_REMOVE_CONTROLS",
3865                                     level, FALSE)) {
3866         return FALSE;
3867     }
3868     return TRUE;
3869 }
3870
3871 static UBool
3872 checkResultLength(UBiDi *pBiDi, const char *srcChars, const char *destChars,
3873                   int32_t destLen, const char* mode,
3874                   const char* option, UBiDiLevel level) {
3875     int32_t actualLen;
3876     if (strcmp(mode, "UBIDI_REORDER_INVERSE_NUMBERS_AS_L") == 0)
3877         actualLen = strlen(destChars);
3878     else
3879         actualLen = ubidi_getResultLength(pBiDi);
3880     if (actualLen != destLen) {
3881         log_err("\nubidi_getResultLength failed.\n%20s %7d\n%20s %7d\n"
3882                 "%20s %s\n%20s %s\n%20s %s\n%20s %s\n%20s %u\n",
3883                 "Expected:", destLen, "Actual:", actualLen,
3884                 "Input:", srcChars, "Output:", destChars,
3885                 "Reordering mode:", mode, "Reordering option:", option,
3886                 "Paragraph level:", level);
3887         return FALSE;
3888     }
3889     return TRUE;
3890 }
3891
3892 static void
3893 testReorderRunsOnly(void) {
3894     static const struct {
3895         const char* textIn;
3896         const char* textOut[2][2];
3897         const char noroundtrip[2];
3898     } testCases[] = {
3899         {"ab 234 896 de", {{"de 896 ab 234", "de 896 ab 234"},                   /*0*/
3900                            {"ab 234 @896@ de", "de 896 ab 234"}}, {0, 0}},
3901         {"abcGHI", {{"GHIabc", "GHIabc"}, {"GHIabc", "GHIabc"}}, {0, 0}},        /*1*/
3902         {"a.>67->", {{"<-67<.a", "<-67<.a"}, {"<-67<.a", "<-67<.a"}}, {0, 0}},   /*2*/
3903         {"-=%$123/ *", {{"* /%$123=-", "* /%$123=-"},                            /*3*/
3904                         {"* /%$123=-", "* /%$123=-"}}, {0, 0}},
3905         {"abc->12..>JKL", {{"JKL<..12<-abc", "JKL<..abc->12"},                   /*4*/
3906                            {"JKL<..12<-abc", "JKL<..abc->12"}}, {0, 0}},
3907         {"JKL->12..>abc", {{"abc<..JKL->12", "abc<..12<-JKL"},                   /*5*/
3908                            {"abc<..JKL->12", "abc<..12<-JKL"}}, {0, 0}},
3909         {"123->abc", {{"abc<-123", "abc<-123"},                                  /*6*/
3910                       {"abc&<-123", "abc<-123"}}, {1, 0}},
3911         {"123->JKL", {{"JKL<-123", "123->JKL"},                                  /*7*/
3912                       {"JKL<-123", "JKL<-@123"}}, {0, 1}},
3913         {"*>12.>34->JKL", {{"JKL<-34<.12<*", "12.>34->JKL<*"},                   /*8*/
3914                            {"JKL<-34<.12<*", "JKL<-@34<.12<*"}}, {0, 1}},
3915         {"*>67.>89->JKL", {{"67.>89->JKL<*", "67.>89->JKL<*"},                   /*9*/
3916                            {"67.>89->JKL<*", "67.>89->JKL<*"}}, {0, 0}},
3917         {"* /abc-=$%123", {{"$%123=-abc/ *", "abc-=$%123/ *"},                   /*10*/
3918                            {"$%123=-abc/ *", "abc-=$%123/ *"}}, {0, 0}},
3919         {"* /$%def-=123", {{"123=-def%$/ *", "def-=123%$/ *"},                   /*11*/
3920                            {"123=-def%$/ *", "def-=123%$/ *"}}, {0, 0}},
3921         {"-=GHI* /123%$", {{"GHI* /123%$=-", "123%$/ *GHI=-"},                   /*12*/
3922                            {"GHI* /123%$=-", "123%$/ *GHI=-"}}, {0, 0}},
3923         {"-=%$JKL* /123", {{"JKL* /%$123=-", "123/ *JKL$%=-"},                   /*13*/
3924                            {"JKL* /%$123=-", "123/ *JKL$%=-"}}, {0, 0}},
3925         {"ab =#CD *?450", {{"CD *?450#= ab", "450?* CD#= ab"},                   /*14*/
3926                            {"CD *?450#= ab", "450?* CD#= ab"}}, {0, 0}},
3927         {"ab 234 896 de", {{"de 896 ab 234", "de 896 ab 234"},                   /*15*/
3928                            {"ab 234 @896@ de", "de 896 ab 234"}}, {0, 0}},
3929         {"abc-=%$LMN* /123", {{"LMN* /%$123=-abc", "123/ *LMN$%=-abc"},          /*16*/
3930                               {"LMN* /%$123=-abc", "123/ *LMN$%=-abc"}}, {0, 0}},
3931         {"123->JKL&MN&P", {{"JKLMNP<-123", "123->JKLMNP"},                       /*17*/
3932                            {"JKLMNP<-123", "JKLMNP<-@123"}}, {0, 1}},
3933         {"123", {{"123", "123"},                /* just one run */               /*18*/
3934                  {"123", "123"}}, {0, 0}}
3935     };
3936     UBiDi *pBiDi = getBiDiObject();
3937     UBiDi *pL2VBiDi = getBiDiObject();
3938     UChar src[MAXLEN], dest[MAXLEN], visual1[MAXLEN], visual2[MAXLEN];
3939     char destChars[MAXLEN], vis1Chars[MAXLEN], vis2Chars[MAXLEN];
3940     int32_t srcLen, destLen, vis1Len, vis2Len, option, i, j, nCases, paras;
3941     UErrorCode rc = U_ZERO_ERROR;
3942     UBiDiLevel level;
3943
3944     log_verbose("\nEntering TestReorderRunsOnly\n\n");
3945
3946     if(!pL2VBiDi) {
3947         ubidi_close(pBiDi);             /* in case this one was allocated */
3948         return;
3949     }
3950     ubidi_setReorderingMode(pBiDi, UBIDI_REORDER_RUNS_ONLY);
3951     ubidi_setReorderingOptions(pL2VBiDi, UBIDI_OPTION_REMOVE_CONTROLS);
3952
3953     for (option = 0; option < 2; option++) {
3954         ubidi_setReorderingOptions(pBiDi, option==0 ? UBIDI_OPTION_REMOVE_CONTROLS
3955                                                     : UBIDI_OPTION_INSERT_MARKS);
3956         for (i = 0, nCases = LENGTHOF(testCases); i < nCases; i++) {
3957             srcLen = strlen(testCases[i].textIn);
3958             pseudoToU16(srcLen, testCases[i].textIn, src);
3959             for(j = 0; j < 2; j++) {
3960                 log_verbose("Now doing test for option %d, case %d, level %d\n",
3961                             i, option, j);
3962                 level = paraLevels[j];
3963                 ubidi_setPara(pBiDi, src, srcLen, level, NULL, &rc);
3964                 assertSuccessful("ubidi_setPara", &rc);
3965                 *dest = 0;
3966                 destLen = ubidi_writeReordered(pBiDi, dest, MAXLEN, UBIDI_DO_MIRRORING, &rc);
3967                 assertSuccessful("ubidi_writeReordered", &rc);
3968                 u16ToPseudo(destLen, dest, destChars);
3969                 checkWhatYouCan(pBiDi, testCases[i].textIn, destChars);
3970                 assertStringsEqual(testCases[i].textOut[option][level], destChars,
3971                         testCases[i].textIn, "UBIDI_REORDER_RUNS_ONLY",
3972                         option==0 ? "0" : "UBIDI_OPTION_INSERT_MARKS",
3973                         pBiDi);
3974
3975                 if((option==0) && testCases[i].noroundtrip[level]) {
3976                     continue;
3977                 }
3978                 ubidi_setPara(pL2VBiDi, src, srcLen, level, NULL, &rc);
3979                 assertSuccessful("ubidi_setPara1", &rc);
3980                 *visual1 = 0;
3981                 vis1Len = ubidi_writeReordered(pL2VBiDi, visual1, MAXLEN, UBIDI_DO_MIRRORING, &rc);
3982                 assertSuccessful("ubidi_writeReordered1", &rc);
3983                 u16ToPseudo(vis1Len, visual1, vis1Chars);
3984                 checkWhatYouCan(pL2VBiDi, testCases[i].textIn, vis1Chars);
3985                 ubidi_setPara(pL2VBiDi, dest, destLen, level^1, NULL, &rc);
3986                 assertSuccessful("ubidi_setPara2", &rc);
3987                 *visual2 = 0;
3988                 vis2Len = ubidi_writeReordered(pL2VBiDi, visual2, MAXLEN, UBIDI_DO_MIRRORING, &rc);
3989                 assertSuccessful("ubidi_writeReordered2", &rc);
3990                 u16ToPseudo(vis2Len, visual2, vis2Chars);
3991                 checkWhatYouCan(pL2VBiDi, destChars, vis2Chars);
3992                 assertStringsEqual(vis1Chars, vis2Chars,
3993                         testCases[i].textIn, "UBIDI_REORDER_RUNS_ONLY (2)",
3994                         option==0 ? "0" : "UBIDI_OPTION_INSERT_MARKS",
3995                         pBiDi);
3996             }
3997         }
3998     }
3999
4000     /* test with null or empty text */
4001     ubidi_setPara(pBiDi, src, 0, UBIDI_LTR, NULL, &rc);
4002     assertSuccessful("ubidi_setPara3", &rc);
4003     paras = ubidi_countParagraphs(pBiDi);
4004     if (paras != 0) {
4005         log_err("\nInvalid number of paras (should be 0): %d\n", paras);
4006     }
4007
4008     ubidi_close(pBiDi);
4009     ubidi_close(pL2VBiDi);
4010
4011     log_verbose("\nExiting TestReorderRunsOnly\n\n");
4012 }
4013
4014 static void
4015 testReorderingMode(void) {
4016
4017     UChar src[MAXLEN], dest[MAXLEN];
4018     char destChars[MAXLEN];
4019     UBiDi *pBiDi = NULL, *pBiDi2 = NULL, *pBiDi3 = NULL;
4020     UErrorCode rc;
4021     int tc, mode, option, level;
4022     uint32_t optionValue, optionBack;
4023     UBiDiReorderingMode modeValue, modeBack;
4024     int32_t srcLen, destLen, idx;
4025     const char *expectedChars;
4026     UBool testOK = TRUE;
4027
4028     log_verbose("\nEntering TestReorderingMode\n\n");
4029
4030     pBiDi = getBiDiObject();
4031     pBiDi2 = getBiDiObject();
4032     pBiDi3 = getBiDiObject();
4033     if(!pBiDi3) {
4034         ubidi_close(pBiDi);             /* in case this one was allocated */
4035         ubidi_close(pBiDi2);            /* in case this one was allocated */
4036         return;
4037     }
4038
4039     ubidi_setInverse(pBiDi2, TRUE);
4040
4041     for (tc = 0; tc < TC_COUNT; tc++) {
4042         const char *srcChars = textIn[tc];
4043         srcLen = strlen(srcChars);
4044         pseudoToU16(srcLen, srcChars, src);
4045
4046         for (mode = 0; mode < MODES_COUNT; mode++) {
4047             modeValue = modes[mode].value;
4048             ubidi_setReorderingMode(pBiDi, modeValue);
4049             modeBack = ubidi_getReorderingMode(pBiDi);
4050             if (modeValue != modeBack) {
4051                 log_err("Error while setting reordering mode to %d, returned %d\n",
4052                         modeValue, modeBack);
4053             }
4054
4055             for (option = 0; option < OPTIONS_COUNT; option++) {
4056                 optionValue = options[option].value;
4057                 ubidi_setReorderingOptions(pBiDi, optionValue);
4058                 optionBack = ubidi_getReorderingOptions(pBiDi);
4059                 if (optionValue != optionBack) {
4060                     log_err("Error while setting reordering option to %d, returned %d\n",
4061                             optionValue, optionBack);
4062                 }
4063
4064                 for (level = 0; level < LEVELS_COUNT; level++) {
4065                     log_verbose("starting test %d mode=%d option=%d level=%d\n",
4066                                 tc, modes[mode].value, options[option].value, level);
4067                     rc = U_ZERO_ERROR;
4068                     ubidi_setPara(pBiDi, src, srcLen, paraLevels[level], NULL, &rc);
4069                     assertSuccessful("ubidi_setPara", &rc);
4070
4071                     *dest = 0;
4072                     destLen = ubidi_writeReordered(pBiDi, dest, MAXLEN,
4073                                                    UBIDI_DO_MIRRORING, &rc);
4074                     assertSuccessful("ubidi_writeReordered", &rc);
4075                     u16ToPseudo(destLen, dest, destChars);
4076                     if (!((modes[mode].value == UBIDI_REORDER_INVERSE_NUMBERS_AS_L) &&
4077                           (options[option].value == UBIDI_OPTION_INSERT_MARKS))) {
4078                         checkWhatYouCan(pBiDi, srcChars, destChars);
4079                     }
4080
4081                     if (modes[mode].value == UBIDI_REORDER_INVERSE_NUMBERS_AS_L) {
4082                         idx = -1;
4083                         expectedChars = inverseBasic(pBiDi2, srcChars, srcLen,
4084                                 options[option].value, paraLevels[level], destChars);
4085                     }
4086                     else {
4087                         idx = outIndices[tc][mode][option][level];
4088                         expectedChars = textOut[idx];
4089                     }
4090                     if (!assertStringsEqual(expectedChars, destChars, srcChars,
4091                                 modes[mode].description,
4092                                 options[option].description,
4093                                 pBiDi)) {
4094                         testOK = FALSE;
4095                     }
4096                     if (options[option].value == UBIDI_OPTION_INSERT_MARKS &&
4097                              !assertRoundTrip(pBiDi3, tc, idx, srcChars,
4098                                               destChars, dest, destLen,
4099                                               mode, option, paraLevels[level])) {
4100                         testOK = FALSE;
4101                     }
4102                     else if (!checkResultLength(pBiDi, srcChars, destChars,
4103                                 destLen, modes[mode].description,
4104                                 options[option].description,
4105                                 paraLevels[level])) {
4106                         testOK = FALSE;
4107                     }
4108                     else if (idx > -1 && !checkMaps(pBiDi, idx, srcChars,
4109                             destChars, modes[mode].description,
4110                             options[option].description, paraLevels[level],
4111                             TRUE)) {
4112                         testOK = FALSE;
4113                     }
4114                 }
4115             }
4116         }
4117     }
4118     if (testOK == TRUE) {
4119         log_verbose("\nReordering mode test OK\n");
4120     }
4121     ubidi_close(pBiDi3);
4122     ubidi_close(pBiDi2);
4123     ubidi_close(pBiDi);
4124
4125     log_verbose("\nExiting TestReorderingMode\n\n");
4126 }
4127
4128 static const char* inverseBasic(UBiDi *pBiDi, const char *srcChars, int32_t srcLen,
4129                                 uint32_t option, UBiDiLevel level, char *result) {
4130     UErrorCode rc = U_ZERO_ERROR;
4131     int32_t destLen;
4132     UChar src[MAXLEN], dest2[MAXLEN];
4133
4134     if (pBiDi == NULL || src == NULL) {
4135         return NULL;
4136     }
4137     ubidi_setReorderingOptions(pBiDi, option);
4138     pseudoToU16(srcLen, srcChars, src);
4139     ubidi_setPara(pBiDi, src, srcLen, level, NULL, &rc);
4140     assertSuccessful("ubidi_setPara", &rc);
4141
4142     *dest2 = 0;
4143     destLen = ubidi_writeReordered(pBiDi, dest2, MAXLEN,
4144                                    UBIDI_DO_MIRRORING, &rc);
4145     assertSuccessful("ubidi_writeReordered", &rc);
4146     u16ToPseudo(destLen, dest2, result);
4147     if (!(option == UBIDI_OPTION_INSERT_MARKS)) {
4148         checkWhatYouCan(pBiDi, srcChars, result);
4149     }
4150     return result;
4151 }
4152
4153 #define NULL_CHAR '\0'
4154
4155 static void
4156 testStreaming(void) {
4157 #define MAXPORTIONS 10
4158
4159     static const struct {
4160         const char* textIn;
4161         short int chunk;
4162         short int nPortions[2];
4163         char  portionLens[2][MAXPORTIONS];
4164         const char* message[2];
4165     } testData[] = {
4166         {   "123\\u000A"
4167             "abc45\\u000D"
4168             "67890\\u000A"
4169             "\\u000D"
4170             "02468\\u000D"
4171             "ghi",
4172             6, { 6, 6 }, {{ 4, 6, 6, 1, 6, 3}, { 4, 6, 6, 1, 6, 3 }},
4173             {"4, 6, 6, 1, 6, 3", "4, 6, 6, 1, 6, 3"}
4174         },
4175         {   "abcd\\u000Afgh\\u000D12345\\u000A456",
4176             6, { 4, 4 }, {{ 5, 4, 6, 3 }, { 5, 4, 6, 3 }},
4177             {"5, 4, 6, 3", "5, 4, 6, 3"}
4178         },
4179         {   "abcd\\u000Afgh\\u000D12345\\u000A45\\u000D",
4180             6, { 4, 4 }, {{ 5, 4, 6, 3 }, { 5, 4, 6, 3 }},
4181             {"5, 4, 6, 3", "5, 4, 6, 3"}
4182         },
4183         {   "abcde\\u000Afghi",
4184             10, { 2, 2 }, {{ 6, 4 }, { 6, 4 }},
4185             {"6, 4", "6, 4"}
4186         }
4187     };
4188     UChar src[MAXLEN];
4189     UBiDi *pBiDi = NULL;
4190     UChar *pSrc;
4191     UErrorCode rc = U_ZERO_ERROR;
4192     int32_t srcLen, processedLen, chunk, len, nPortions;
4193     int i, j, levelIndex;
4194     UBiDiLevel level;
4195     int nTests = LENGTHOF(testData), nLevels = LENGTHOF(paraLevels);
4196     UBool mismatch, testOK = TRUE;
4197    char processedLenStr[MAXPORTIONS * 5];
4198
4199     log_verbose("\nEntering TestStreaming\n\n");
4200
4201     pBiDi = getBiDiObject();
4202
4203     ubidi_orderParagraphsLTR(pBiDi, TRUE);
4204
4205     for (levelIndex = 0; levelIndex < nLevels; levelIndex++) {
4206         for (i = 0; i < nTests; i++) {
4207             srcLen = u_unescape(testData[i].textIn, src, MAXLEN);
4208             chunk = testData[i].chunk;
4209             nPortions = testData[i].nPortions[levelIndex];
4210             level = paraLevels[levelIndex];
4211             processedLenStr[0] = NULL_CHAR;
4212             log_verbose("Testing level %d, case %d\n", level, i);
4213
4214             mismatch = FALSE;
4215
4216             ubidi_setReorderingOptions(pBiDi, UBIDI_OPTION_STREAMING);
4217             for (j = 0, pSrc = src; j < MAXPORTIONS && srcLen > 0; j++) {
4218
4219                 len = chunk < srcLen ? chunk : srcLen;
4220                 ubidi_setPara(pBiDi, pSrc, len, level, NULL, &rc);
4221                 if (!assertSuccessful("ubidi_setPara", &rc)) {
4222                     break;
4223                 }
4224
4225                 processedLen = ubidi_getProcessedLength(pBiDi);
4226                 if (processedLen == 0) {
4227                     ubidi_setReorderingOptions(pBiDi, UBIDI_OPTION_DEFAULT);
4228                     j--;
4229                     continue;
4230                 }
4231                 ubidi_setReorderingOptions(pBiDi, UBIDI_OPTION_STREAMING);
4232
4233                 mismatch |= (UBool)(j >= nPortions ||
4234                            processedLen != testData[i].portionLens[levelIndex][j]);
4235
4236                 sprintf(processedLenStr + j * 4, "%4d", processedLen);
4237                 srcLen -= processedLen, pSrc += processedLen;
4238             }
4239
4240             if (mismatch || j != nPortions) {
4241                 testOK = FALSE;
4242                 log_err("\nProcessed lengths mismatch.\n"
4243                     "\tParagraph level: %u\n"
4244                     "\tInput string: %s\n"
4245                     "\tActually processed portion lengths: { %s }\n"
4246                     "\tExpected portion lengths          : { %s }\n",
4247                     paraLevels[levelIndex], testData[i].textIn,
4248                     processedLenStr, testData[i].message[levelIndex]);
4249             }
4250         }
4251     }
4252     ubidi_close(pBiDi);
4253     if (testOK == TRUE) {
4254         log_verbose("\nBiDi streaming test OK\n");
4255     }
4256     log_verbose("\nExiting TestStreaming\n\n");
4257 }
4258
4259 U_CDECL_BEGIN
4260
4261 static UCharDirection U_CALLCONV
4262 overrideBidiClass(const void *context, UChar32 c) {
4263
4264 #define DEF U_BIDI_CLASS_DEFAULT
4265
4266     static const UCharDirection customClasses[] = {
4267        /* 0/8    1/9    2/A    3/B    4/C    5/D    6/E    7/F  */
4268           DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 00-07 */
4269           DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 08-0F */
4270           DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 10-17 */
4271           DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 18-1F */
4272           DEF,   DEF,   DEF,   DEF,   DEF,   DEF,     R,   DEF, /* 20-27 */
4273           DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 28-2F */
4274            EN,    EN,    EN,    EN,    EN,    EN,    AN,    AN, /* 30-37 */
4275            AN,    AN,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 38-3F */
4276             L,    AL,    AL,    AL,    AL,    AL,    AL,     R, /* 40-47 */
4277             R,     R,     R,     R,     R,     R,     R,     R, /* 48-4F */
4278             R,     R,     R,     R,     R,     R,     R,     R, /* 50-57 */
4279             R,     R,     R,   LRE,   DEF,   RLE,   PDF,     S, /* 58-5F */
4280           NSM,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 60-67 */
4281           DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 68-6F */
4282           DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 70-77 */
4283           DEF,   DEF,   DEF,   LRO,     B,   RLO,    BN,   DEF  /* 78-7F */
4284     };
4285     static const int nEntries = LENGTHOF(customClasses);
4286     const char *dummy = context;        /* just to avoid a compiler warning */
4287     dummy++;
4288
4289     return c >= nEntries ? U_BIDI_CLASS_DEFAULT : customClasses[c];
4290 }
4291
4292 U_CDECL_END
4293
4294 static void verifyCallbackParams(UBiDiClassCallback* fn, const void* context,
4295                                  UBiDiClassCallback* expectedFn,
4296                                  const void* expectedContext,
4297                                  int32_t sizeOfContext) {
4298     if (fn != expectedFn) {
4299         log_err("Class callback pointer is not set properly.\n");
4300     }
4301     if (context != expectedContext) {
4302         log_err("Class callback context is not set properly.\n");
4303     }
4304     else if (context != NULL &&
4305             memcmp(context, expectedContext, sizeOfContext)) {
4306         log_err("Callback context content doesn't match the expected one.\n");
4307     }
4308 }
4309
4310 static void
4311 testClassOverride(void) {
4312     static const char* const textSrc  = "JIH.>12->a \\u05D0\\u05D1 6 ABC78";
4313     static const char* const textResult = "12<.HIJ->a 78CBA 6 \\u05D1\\u05D0";
4314
4315     UChar src[MAXLEN], dest[MAXLEN];
4316     UErrorCode rc = U_ZERO_ERROR;
4317     UBiDi *pBiDi = NULL;
4318     UBiDiClassCallback* oldFn = NULL;
4319     UBiDiClassCallback* newFn = overrideBidiClass;
4320     const void* oldContext = NULL;
4321     int32_t srcLen, destLen, textSrcSize = (int32_t)uprv_strlen(textSrc);
4322     char* destChars = NULL;
4323
4324     log_verbose("\nEntering TestClassOverride\n\n");
4325
4326     pBiDi = getBiDiObject();
4327     if(!pBiDi) {
4328         return;
4329     }
4330
4331     ubidi_getClassCallback(pBiDi, &oldFn, &oldContext);
4332     verifyCallbackParams(oldFn, oldContext, NULL, NULL, 0);
4333
4334     ubidi_setClassCallback(pBiDi, newFn, textSrc, &oldFn, &oldContext, &rc);
4335     if (!assertSuccessful("ubidi_setClassCallback", &rc)) {
4336         ubidi_close(pBiDi);
4337         return;
4338     }
4339     verifyCallbackParams(oldFn, oldContext, NULL, NULL, 0);
4340
4341     ubidi_getClassCallback(pBiDi, &oldFn, &oldContext);
4342     verifyCallbackParams(oldFn, oldContext, newFn, textSrc, textSrcSize);
4343
4344     ubidi_setClassCallback(pBiDi, newFn, textSrc, &oldFn, &oldContext, &rc);
4345     if (!assertSuccessful("ubidi_setClassCallback", &rc)) {
4346         ubidi_close(pBiDi);
4347         return;
4348     }
4349     verifyCallbackParams(oldFn, oldContext, newFn, textSrc, textSrcSize);
4350
4351     srcLen = u_unescape(textSrc, src, MAXLEN);
4352     ubidi_setPara(pBiDi, src, srcLen, UBIDI_LTR, NULL, &rc);
4353     assertSuccessful("ubidi_setPara", &rc);
4354
4355     destLen = ubidi_writeReordered(pBiDi, dest, MAXLEN,
4356                                    UBIDI_DO_MIRRORING, &rc);
4357     assertSuccessful("ubidi_writeReordered", &rc);
4358
4359     destChars = aescstrdup(dest, destLen);
4360     if (uprv_strcmp(textResult, destChars)) {
4361         log_err("\nActual and expected output mismatch.\n"
4362             "%20s %s\n%20s %s\n%20s %s\n",
4363             "Input:", textSrc, "Actual output:", destChars,
4364             "Expected output:", textResult);
4365     }
4366     else {
4367         log_verbose("\nClass override test OK\n");
4368     }
4369     ubidi_close(pBiDi);
4370     log_verbose("\nExiting TestClassOverride\n\n");
4371 }
4372
4373 static char * formatMap(const int32_t * map, int len, char * buffer)
4374 {
4375     int32_t i, k;
4376     char c;
4377     for (i = 0; i < len; i++) {
4378         k = map[i];
4379         if (k < 0)
4380             c = '-';
4381         else if (k >= sizeof(columns))
4382             c = '+';
4383         else
4384             c = columns[k];
4385         buffer[i] = c;
4386     }
4387     buffer[len] = '\0';
4388     return buffer;
4389 }
4390
4391 static UBool
4392 checkMaps(UBiDi *pBiDi, int32_t stringIndex, const char *src, const char *dest,
4393           const char *mode, const char* option, UBiDiLevel level, UBool forward)
4394 {
4395     int32_t actualLogicalMap[MAX_MAP_LENGTH];
4396     int32_t actualVisualMap[MAX_MAP_LENGTH];
4397     int32_t getIndexMap[MAX_MAP_LENGTH];
4398     int32_t i, srcLen, resLen, idx;
4399     const int32_t *expectedLogicalMap, *expectedVisualMap;
4400     UErrorCode rc = U_ZERO_ERROR;
4401     UBool testOK = TRUE;
4402
4403     if (forward) {
4404         expectedLogicalMap = forwardMap[stringIndex];
4405         expectedVisualMap  = inverseMap[stringIndex];
4406     }
4407     else {
4408         expectedLogicalMap = inverseMap[stringIndex];
4409         expectedVisualMap  = forwardMap[stringIndex];
4410     }
4411     ubidi_getLogicalMap(pBiDi, actualLogicalMap, &rc);
4412     if (!assertSuccessful("ubidi_getLogicalMap", &rc)) {
4413         testOK = FALSE;
4414     }
4415     srcLen = ubidi_getProcessedLength(pBiDi);
4416     if (memcmp(expectedLogicalMap, actualLogicalMap, srcLen * sizeof(int32_t))) {
4417         char expChars[MAX_MAP_LENGTH];
4418         char actChars[MAX_MAP_LENGTH];
4419         log_err("\nubidi_getLogicalMap() returns unexpected map for output string "
4420                 "index %d\n"
4421                 "source: %s\n"
4422                 "dest  : %s\n"
4423                 "Scale : %s\n"
4424                 "ExpMap: %s\n"
4425                 "Actual: %s\n"
4426                 "Paragraph level  : %d == %d\n"
4427                 "Reordering mode  : %s == %d\n"
4428                 "Reordering option: %s == %d\n"
4429                 "Forward flag     : %d\n",
4430                 stringIndex, src, dest, columns,
4431                 formatMap(expectedLogicalMap, srcLen, expChars),
4432                 formatMap(actualLogicalMap, srcLen, actChars),
4433                 level, ubidi_getParaLevel(pBiDi),
4434                 mode, ubidi_getReorderingMode(pBiDi),
4435                 option, ubidi_getReorderingOptions(pBiDi),
4436                 forward
4437                 );
4438         testOK = FALSE;
4439     }
4440     resLen = ubidi_getResultLength(pBiDi);
4441     ubidi_getVisualMap(pBiDi, actualVisualMap, &rc);
4442     assertSuccessful("ubidi_getVisualMap", &rc);
4443     if (memcmp(expectedVisualMap, actualVisualMap, resLen * sizeof(int32_t))) {
4444         char expChars[MAX_MAP_LENGTH];
4445         char actChars[MAX_MAP_LENGTH];
4446         log_err("\nubidi_getVisualMap() returns unexpected map for output string "
4447                 "index %d\n"
4448                 "source: %s\n"
4449                 "dest  : %s\n"
4450                 "Scale : %s\n"
4451                 "ExpMap: %s\n"
4452                 "Actual: %s\n"
4453                 "Paragraph level  : %d == %d\n"
4454                 "Reordering mode  : %s == %d\n"
4455                 "Reordering option: %s == %d\n"
4456                 "Forward flag     : %d\n",
4457                 stringIndex, src, dest, columns,
4458                 formatMap(expectedVisualMap, resLen, expChars),
4459                 formatMap(actualVisualMap, resLen, actChars),
4460                 level, ubidi_getParaLevel(pBiDi),
4461                 mode, ubidi_getReorderingMode(pBiDi),
4462                 option, ubidi_getReorderingOptions(pBiDi),
4463                 forward
4464                 );
4465         testOK = FALSE;
4466     }
4467     for (i = 0; i < srcLen; i++) {
4468         idx = ubidi_getVisualIndex(pBiDi, i, &rc);
4469         assertSuccessful("ubidi_getVisualIndex", &rc);
4470         getIndexMap[i] = idx;
4471     }
4472     if (memcmp(actualLogicalMap, getIndexMap, srcLen * sizeof(int32_t))) {
4473         char actChars[MAX_MAP_LENGTH];
4474         char gotChars[MAX_MAP_LENGTH];
4475         log_err("\nMismatch between ubidi_getLogicalMap and ubidi_getVisualIndex for output string "
4476                 "index %d\n"
4477                 "source: %s\n"
4478                 "dest  : %s\n"
4479                 "Scale : %s\n"
4480                 "ActMap: %s\n"
4481                 "IdxMap: %s\n"
4482                 "Paragraph level  : %d == %d\n"
4483                 "Reordering mode  : %s == %d\n"
4484                 "Reordering option: %s == %d\n"
4485                 "Forward flag     : %d\n",
4486                 stringIndex, src, dest, columns,
4487                 formatMap(actualLogicalMap, srcLen, actChars),
4488                 formatMap(getIndexMap, srcLen, gotChars),
4489                 level, ubidi_getParaLevel(pBiDi),
4490                 mode, ubidi_getReorderingMode(pBiDi),
4491                 option, ubidi_getReorderingOptions(pBiDi),
4492                 forward
4493                 );
4494         testOK = FALSE;
4495     }
4496     for (i = 0; i < resLen; i++) {
4497         idx = ubidi_getLogicalIndex(pBiDi, i, &rc);
4498         assertSuccessful("ubidi_getLogicalIndex", &rc);
4499         getIndexMap[i] = idx;
4500     }
4501     if (memcmp(actualVisualMap, getIndexMap, resLen * sizeof(int32_t))) {
4502         char actChars[MAX_MAP_LENGTH];
4503         char gotChars[MAX_MAP_LENGTH];
4504         log_err("\nMismatch between ubidi_getVisualMap and ubidi_getLogicalIndex for output string "
4505                 "index %d\n"
4506                 "source: %s\n"
4507                 "dest  : %s\n"
4508                 "Scale : %s\n"
4509                 "ActMap: %s\n"
4510                 "IdxMap: %s\n"
4511                 "Paragraph level  : %d == %d\n"
4512                 "Reordering mode  : %s == %d\n"
4513                 "Reordering option: %s == %d\n"
4514                 "Forward flag     : %d\n",
4515                 stringIndex, src, dest, columns,
4516                 formatMap(actualVisualMap, resLen, actChars),
4517                 formatMap(getIndexMap, resLen, gotChars),
4518                 level, ubidi_getParaLevel(pBiDi),
4519                 mode, ubidi_getReorderingMode(pBiDi),
4520                 option, ubidi_getReorderingOptions(pBiDi),
4521                 forward
4522                 );
4523         testOK = FALSE;
4524     }
4525     return testOK;
4526 }
4527
4528 static UBool
4529 assertIllegalArgument(const char* message, UErrorCode* rc) {
4530     if (*rc != U_ILLEGAL_ARGUMENT_ERROR) {
4531         log_err("%s() failed with error %s.\n", message, myErrorName(*rc));
4532         return FALSE;
4533     }
4534     return TRUE;
4535 }
4536
4537 typedef struct {
4538     const char* prologue;
4539     const char* source;
4540     const char* epilogue;
4541     const char* expected;
4542     UBiDiLevel paraLevel;
4543 } contextCase;
4544
4545 static const contextCase contextData[] = {
4546     /*00*/  {"", "", "", "", UBIDI_LTR},
4547     /*01*/  {"", ".-=JKL-+*", "", ".-=LKJ-+*", UBIDI_LTR},
4548     /*02*/  {" ", ".-=JKL-+*", " ", ".-=LKJ-+*", UBIDI_LTR},
4549     /*03*/  {"a", ".-=JKL-+*", "b", ".-=LKJ-+*", UBIDI_LTR},
4550     /*04*/  {"D", ".-=JKL-+*", "", "LKJ=-.-+*", UBIDI_LTR},
4551     /*05*/  {"", ".-=JKL-+*", " D", ".-=*+-LKJ", UBIDI_LTR},
4552     /*06*/  {"", ".-=JKL-+*", " 2", ".-=*+-LKJ", UBIDI_LTR},
4553     /*07*/  {"", ".-=JKL-+*", " 7", ".-=*+-LKJ", UBIDI_LTR},
4554     /*08*/  {" G 1", ".-=JKL-+*", " H", "*+-LKJ=-.", UBIDI_LTR},
4555     /*09*/  {"7", ".-=JKL-+*", " H", ".-=*+-LKJ", UBIDI_LTR},
4556     /*10*/  {"", ".-=abc-+*", "", "*+-abc=-.", UBIDI_RTL},
4557     /*11*/  {" ", ".-=abc-+*", " ", "*+-abc=-.", UBIDI_RTL},
4558     /*12*/  {"D", ".-=abc-+*", "G", "*+-abc=-.", UBIDI_RTL},
4559     /*13*/  {"x", ".-=abc-+*", "", "*+-.-=abc", UBIDI_RTL},
4560     /*14*/  {"", ".-=abc-+*", " y", "abc-+*=-.", UBIDI_RTL},
4561     /*15*/  {"", ".-=abc-+*", " 2", "abc-+*=-.", UBIDI_RTL},
4562     /*16*/  {" x 1", ".-=abc-+*", " 2", ".-=abc-+*", UBIDI_RTL},
4563     /*17*/  {" x 7", ".-=abc-+*", " 8", "*+-.-=abc", UBIDI_RTL},
4564     /*18*/  {"x|", ".-=abc-+*", " 8", "*+-abc=-.", UBIDI_RTL},
4565     /*19*/  {"G|y", ".-=abc-+*", " 8", "*+-.-=abc", UBIDI_RTL},
4566     /*20*/  {"", ".-=", "", ".-=", UBIDI_DEFAULT_LTR},
4567     /*21*/  {"D", ".-=", "", "=-.", UBIDI_DEFAULT_LTR},
4568     /*22*/  {"G", ".-=", "", "=-.", UBIDI_DEFAULT_LTR},
4569     /*23*/  {"xG", ".-=", "", ".-=", UBIDI_DEFAULT_LTR},
4570     /*24*/  {"x|G", ".-=", "", "=-.", UBIDI_DEFAULT_LTR},
4571     /*25*/  {"x|G", ".-=|-+*", "", "=-.|-+*", UBIDI_DEFAULT_LTR},
4572 };
4573 #define CONTEXT_COUNT       LENGTHOF(contextData)
4574
4575 static void
4576 testContext(void) {
4577
4578     UChar prologue[MAXLEN], epilogue[MAXLEN], src[MAXLEN], dest[MAXLEN];
4579     char destChars[MAXLEN];
4580     UBiDi *pBiDi = NULL;
4581     UErrorCode rc;
4582     int32_t proLength, epiLength, srcLen, destLen, tc;
4583     contextCase cc;
4584     UBool testOK = TRUE;
4585
4586     log_verbose("\nEntering TestContext \n\n");
4587
4588     /* test null BiDi object */
4589     rc = U_ZERO_ERROR;
4590     ubidi_setContext(pBiDi, NULL, 0, NULL, 0, &rc);
4591     testOK &= assertIllegalArgument("Error when BiDi object is null", &rc);
4592
4593     pBiDi = getBiDiObject();
4594     ubidi_orderParagraphsLTR(pBiDi, TRUE);
4595
4596     /* test proLength < -1 */
4597     rc = U_ZERO_ERROR;
4598     ubidi_setContext(pBiDi, NULL, -2, NULL, 0, &rc);
4599     testOK &= assertIllegalArgument("Error when proLength < -1", &rc);
4600     /* test epiLength < -1 */
4601     rc = U_ZERO_ERROR;
4602     ubidi_setContext(pBiDi, NULL, 0, NULL, -2, &rc);
4603     testOK &= assertIllegalArgument("Error when epiLength < -1", &rc);
4604     /* test prologue == NULL */
4605     rc = U_ZERO_ERROR;
4606     ubidi_setContext(pBiDi, NULL, 3, NULL, 0, &rc);
4607     testOK &= assertIllegalArgument("Prologue is NULL", &rc);
4608     /* test epilogue == NULL */
4609     rc = U_ZERO_ERROR;
4610     ubidi_setContext(pBiDi, NULL, 0, NULL, 4, &rc);
4611     testOK &= assertIllegalArgument("Epilogue is NULL", &rc);
4612
4613     for (tc = 0; tc < CONTEXT_COUNT; tc++) {
4614         cc = contextData[tc];
4615         proLength = strlen(cc.prologue);
4616         pseudoToU16(proLength, cc.prologue, prologue);
4617         epiLength = strlen(cc.epilogue);
4618         pseudoToU16(epiLength, cc.epilogue, epilogue);
4619         /* in the call below, prologue and epilogue are swapped to show
4620            that the next call will override this call */
4621         rc = U_ZERO_ERROR;
4622         ubidi_setContext(pBiDi, epilogue, epiLength, prologue, proLength, &rc);
4623         testOK &= assertSuccessful("swapped ubidi_setContext", &rc);
4624         ubidi_setContext(pBiDi, prologue, -1, epilogue, -1, &rc);
4625         testOK &= assertSuccessful("regular ubidi_setContext", &rc);
4626         srcLen = strlen(cc.source);
4627         pseudoToU16(srcLen, cc.source, src);
4628         ubidi_setPara(pBiDi, src, srcLen, cc.paraLevel, NULL, &rc);
4629         testOK &= assertSuccessful("ubidi_setPara", &rc);
4630         destLen = ubidi_writeReordered(pBiDi, dest, MAXLEN, UBIDI_DO_MIRRORING, &rc);
4631         assertSuccessful("ubidi_writeReordered", &rc);
4632         u16ToPseudo(destLen, dest, destChars);
4633         if (uprv_strcmp(cc.expected, destChars)) {
4634             char formatChars[MAXLEN];
4635             log_err("\nActual and expected output mismatch on case %d.\n"
4636                 "%20s %s\n%20s %s\n%20s %s\n%20s %s\n%20s %s\n%20s %s\n%20s %d\n%20s %u\n%20s %d\n",
4637                 tc,
4638                 "Prologue:", cc.prologue,
4639                 "Input:", cc.source,
4640                 "Epilogue:", cc.epilogue,
4641                 "Expected output:", cc.expected,
4642                 "Actual output:", destChars,
4643                 "Levels:", formatLevels(pBiDi, formatChars),
4644                 "Reordering mode:", ubidi_getReorderingMode(pBiDi),
4645                 "Paragraph level:", ubidi_getParaLevel(pBiDi),
4646                 "Reordering option:", ubidi_getReorderingOptions(pBiDi));
4647             testOK = FALSE;
4648         }
4649     }
4650     if (testOK == TRUE) {
4651         log_verbose("\nContext test OK\n");
4652     }
4653     ubidi_close(pBiDi);
4654
4655     log_verbose("\nExiting TestContext \n\n");
4656 }