Update ICU to 54.1 step 1

source/test/cintltst/cbiditst.c

 /********************************************************************
  * COPYRIGHT:
- * Copyright (c) 1997-2013, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /*   file name:  cbiditst.c
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 1999sep27
 *   created by: Markus W. Scherer, updated by Matitiahu Allouche
 */
 
 #include "cintltst.h"
 #include "unicode/utypes.h"
 #include "unicode/uchar.h"
 #include "unicode/ustring.h"
 #include "unicode/ubidi.h"
 #include "unicode/ushape.h"
 #include "cbiditst.h"
 #include "cstring.h"
 /* the following include is needed for sprintf */
 #include <stdio.h>
 
 #define MAXLEN      MAX_STRING_LENGTH
-#define LENGTHOF(array) (sizeof(array)/sizeof((array)[0]))
 
 /* prototypes ---------------------------------------------------------------*/
 
 void addComplexTest(TestNode** root);
 
 static void testCharFromDirProp(void);
 
 static void testBidi(void);
 
 static void doTests(UBiDi *pBiDi, UBiDi *pLine, UBool countRunsFirst);
@@ skipping 25 matching lines @@
 static void doTashkeelSpecialVLTRArabicShapingTest(void);
 
 static void doLOGICALArabicDeShapingTest(void);
 
 static void doArabicShapingTestForBug5421(void);
 
 static void doArabicShapingTestForBug8703(void);
 
 static void doArabicShapingTestForBug9024(void);
 
+static void _testPresentationForms(const UChar *in);
+
+static void doArabicShapingTestForNewCharacters(void);
+
 static void testReorder(void);
 
 static void testReorderArabicMathSymbols(void);
 
 static void testFailureRecovery(void);
 
 static void testMultipleParagraphs(void);
 
 static void testGetBaseDirection(void);
 
@@ skipping 53 matching lines @@
 
     addTest(root, doArabicShapingTest, "complex/arabic-shaping/ArabicShapingTest");
     addTest(root, doLamAlefSpecialVLTRArabicShapingTest, "complex/arabic-shaping/lamalef");
     addTest(root, doTashkeelSpecialVLTRArabicShapingTest, "complex/arabic-shaping/tashkeel");
     addTest(root, doLOGICALArabicDeShapingTest, "complex/arabic-shaping/unshaping");
     addTest(root, doArabicShapingTestForBug5421, "complex/arabic-shaping/bug-5421");
     addTest(root, doTailTest, "complex/arabic-shaping/tailtest");
     addTest(root, doArabicShapingTestForBug8703, "complex/arabic-shaping/bug-8703");
     addTest(root, testReorderArabicMathSymbols, "complex/bidi/bug-9024");
     addTest(root, doArabicShapingTestForBug9024, "complex/arabic-shaping/bug-9024");
+    addTest(root, doArabicShapingTestForNewCharacters, "complex/arabic-shaping/shaping2");
 }
 
 static void
 testCharFromDirProp(void) {
     /* verify that the exemplar characters have the expected bidi classes */
     int32_t i;
 
     log_verbose("\nEntering TestCharFromDirProp\n\n");
     initCharFromDirProps();
 
@@ skipping 565 matching lines @@
             "helloGEMPD",
             "hello ZYXW"
     };
     char formatChars[MAXLEN];
     UErrorCode ec = U_ZERO_ERROR;
     UBiDi* bidi = ubidi_open();
     int i;
 
     log_verbose("\nEntering TestReorder\n\n");
 
-    for(i=0;i<LENGTHOF(logicalOrder);i++){
+    for(i=0;i<UPRV_LENGTHOF(logicalOrder);i++){
         int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
         int32_t destSize = srcSize*2;
         UChar src[MAXLEN];
         UChar dest[MAXLEN];
         char chars[MAXLEN];
         log_verbose("Testing L2V #1 for case %d\n", i);
         pseudoToU16(srcSize,logicalOrder[i],src);
         ec = U_ZERO_ERROR;
         ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec);
         if(U_FAILURE(ec)){
@@ skipping 14 matching lines @@
         if(destSize!=srcSize){
             log_err("ubidi_writeReordered() destSize and srcSize do not match\n");
         }else if(strcmp(visualOrder[i],chars)!=0){
             log_err("ubidi_writeReordered() did not give expected results for UBIDI_DO_MIRRORING.\n"
                     "Input   : %s\nExpected: %s\nGot     : %s\nLevels  : %s\nAt Index: %d\n",
                     logicalOrder[i],visualOrder[i],chars,formatLevels(bidi, formatChars),i);
         }
         checkWhatYouCan(bidi, logicalOrder[i], chars);
     }
 
-    for(i=0;i<LENGTHOF(logicalOrder);i++){
+    for(i=0;i<UPRV_LENGTHOF(logicalOrder);i++){
         int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
         int32_t destSize = srcSize*2;
         UChar src[MAXLEN];
         UChar dest[MAXLEN];
         char chars[MAXLEN];
         log_verbose("Testing L2V #2 for case %d\n", i);
         pseudoToU16(srcSize,logicalOrder[i],src);
         ec = U_ZERO_ERROR;
         ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec);
         if(U_FAILURE(ec)){
@@ skipping 13 matching lines @@
         u16ToPseudo(destSize,dest,chars);
         if(destSize!=srcSize){
             log_err("ubidi_writeReordered() destSize and srcSize do not match\n");
         }else if(strcmp(visualOrder1[i],chars)!=0){
             log_err("ubidi_writeReordered() did not give expected results for UBIDI_DO_MIRRORING+UBIDI_OUTPUT_REVERSE.\n"
                     "Input   : %s\nExpected: %s\nGot     : %s\nLevels  : %s\nAt Index: %d\n",
                     logicalOrder[i],visualOrder1[i],chars,formatLevels(bidi, formatChars),i);
         }
     }
 
-    for(i=0;i<LENGTHOF(logicalOrder);i++){
+    for(i=0;i<UPRV_LENGTHOF(logicalOrder);i++){
         int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
         int32_t destSize = srcSize*2;
         UChar src[MAXLEN];
         UChar dest[MAXLEN];
         char chars[MAXLEN];
         log_verbose("Testing V2L #3 for case %d\n", i);
         pseudoToU16(srcSize,logicalOrder[i],src);
         ec = U_ZERO_ERROR;
         ubidi_setInverse(bidi,TRUE);
         ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec);
@@ skipping 10 matching lines @@
         }
         destSize=ubidi_writeReordered(bidi,dest,destSize+1,UBIDI_INSERT_LRM_FOR_NUMERIC+UBIDI_OUTPUT_REVERSE,&ec);
         u16ToPseudo(destSize,dest,chars);
         if(strcmp(visualOrder2[i],chars)!=0){
             log_err("ubidi_writeReordered() did not give expected results for UBIDI_INSERT_LRM_FOR_NUMERIC+UBIDI_OUTPUT_REVERSE.\n"
                     "Input   : %s\nExpected: %s\nGot     : %s\nLevels  : %s\nAt Index: %d\n",
                     logicalOrder[i],visualOrder2[i],chars,formatLevels(bidi, formatChars),i);
         }
     }
         /* Max Explicit level */
-    for(i=0;i<LENGTHOF(logicalOrder);i++){
+    for(i=0;i<UPRV_LENGTHOF(logicalOrder);i++){
         int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
         int32_t destSize = srcSize*2;
         UChar src[MAXLEN];
         UChar dest[MAXLEN];
         char chars[MAXLEN];
         UBiDiLevel levels[UBIDI_MAX_EXPLICIT_LEVEL]={1,2,3,4,5,6,7,8,9,10};
         log_verbose("Testing V2L #4 for case %d\n", i);
         pseudoToU16(srcSize,logicalOrder[i],src);
         ec = U_ZERO_ERROR;
         ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR,levels,&ec);
@@ skipping 13 matching lines @@
         destSize=ubidi_writeReordered(bidi,dest,destSize+1,UBIDI_OUTPUT_REVERSE,&ec);
         u16ToPseudo(destSize,dest,chars);
         if(destSize!=srcSize){
             log_err("ubidi_writeReordered() destSize and srcSize do not match. Dest Size = %d Source Size = %d\n",destSize,srcSize );
         }else if(strcmp(visualOrder3[i],chars)!=0){
             log_err("ubidi_writeReordered() did not give expected results for UBIDI_OUTPUT_REVERSE.\n"
                     "Input   : %s\nExpected: %s\nGot     : %s\nLevels  : %s\nAt Index: %d\n",
                     logicalOrder[i],visualOrder3[i],chars,formatLevels(bidi, formatChars),i);
         }
     }
-    for(i=0;i<LENGTHOF(logicalOrder);i++){
+    for(i=0;i<UPRV_LENGTHOF(logicalOrder);i++){
         int32_t srcSize = (int32_t)strlen(logicalOrder[i]);
         int32_t destSize = srcSize*2;
         UChar src[MAXLEN];
         UChar dest[MAXLEN];
         char chars[MAXLEN];
         UBiDiLevel levels[UBIDI_MAX_EXPLICIT_LEVEL]={1,2,3,4,5,6,7,8,9,10};
         log_verbose("Testing V2L #5 for case %d\n", i);
         pseudoToU16(srcSize,logicalOrder[i],src);
         ec = U_ZERO_ERROR;
         ubidi_setPara(bidi,src,srcSize,UBIDI_DEFAULT_LTR,levels,&ec);
@@ skipping 107 matching lines @@
         0xD83B, 0xDE4F, 0xD83B, 0xDE4E, 0xD83B, 0xDE4D, 0x20,
         0xD83B, 0xDE4B, 0xD83B, 0xDE49, 0xD83B, 0xDE47, 0xD83B, 0xDE42}
     };
     char formatChars[MAXLEN];
     UErrorCode ec = U_ZERO_ERROR;
     UBiDi* bidi = ubidi_open();
     int i;
 
     log_verbose("\nEntering TestReorderArabicMathSymbols\n\n");
 
-    for(i=0;i<LENGTHOF(logicalOrder);i++){
+    for(i=0;i<UPRV_LENGTHOF(logicalOrder);i++){
         int32_t srcSize = u_strlen(logicalOrder[i]);
         int32_t destSize = srcSize*2;
         UChar dest[MAXLEN];
         log_verbose("Testing L2V #1 for case %d\n", i);
         ec = U_ZERO_ERROR;
         ubidi_setPara(bidi,logicalOrder[i],srcSize,UBIDI_DEFAULT_LTR ,NULL,&ec);
         if(U_FAILURE(ec)){
             log_err("ubidi_setPara(tests[%d], paraLevel %d) failed with errorCode %s\n",
                     i, UBIDI_DEFAULT_LTR, u_errorName(ec));
         }
@@ skipping 271 matching lines @@
         }
     }
 }
 
 #define RETURN_IF_BAD_ERRCODE(x)    \
     if (U_FAILURE(errorCode)) {      \
         log_err("\nbad errorCode %d at %s\n", errorCode, (x));  \
         return;     \
     }               \
 
-#define STRING_TEST_CASE(s) { (s), LENGTHOF(s) }
+#define STRING_TEST_CASE(s) { (s), UPRV_LENGTHOF(s) }
 
 static void testGetBaseDirection(void) {
     UBiDiDirection dir;
     int i;
 
 /* Test Data */
     static const UChar
 /*Mixed Start with L*/
     stringMixedEnglishFirst[]={ 0x61, 0x627, 0x32, 0x6f3, 0x61, 0x34, 0 },
 /*Mixed Start with AL*/
@@ skipping 49 matching lines @@
 /* Expected results */
     static const UBiDiDirection expectedDir[] ={
         UBIDI_LTR, UBIDI_RTL, UBIDI_RTL,
         UBIDI_RTL, UBIDI_RTL, UBIDI_LTR,
         UBIDI_LTR, UBIDI_RTL, UBIDI_NEUTRAL,
         UBIDI_LTR, UBIDI_NEUTRAL, UBIDI_NEUTRAL,
         UBIDI_NEUTRAL, UBIDI_LTR, UBIDI_RTL
     };
 
     log_verbose("testGetBaseDirection() with %u test cases ---\n",
-    LENGTHOF(testCases));
+    UPRV_LENGTHOF(testCases));
 /* Run Tests */
-     for(i=0; i<LENGTHOF(testCases); ++i) {
+     for(i=0; i<UPRV_LENGTHOF(testCases); ++i) {
         dir = ubidi_getBaseDirection(testCases[i].s, testCases[i].length );
         log_verbose("Testing case %d\tReceived dir %d\n", i, dir);
         if (dir != expectedDir[i])
             log_err("\nFailed getBaseDirection case %d Expected  %d \tReceived %d\n",
             i, expectedDir[i], dir);
     }
 
 /* Misc. tests */
 /* NULL string */
     dir = ubidi_getBaseDirection(NULL, 3);
@@ skipping 754 matching lines @@
     }
 
     ubidi_close(pLine);
     ubidi_close(pBidi);
     log_verbose("\nExiting TestMultipleParagraphs\n\n");
 
     /* check levels in multiple paragraphs with default para level
      */
     pBidi = ubidi_open();
     errorCode = U_ZERO_ERROR;
-    ubidi_setPara(pBidi, multiparaTestString, LENGTHOF(multiparaTestString),
+    ubidi_setPara(pBidi, multiparaTestString, UPRV_LENGTHOF(multiparaTestString),
                   UBIDI_DEFAULT_LTR, NULL, &errorCode);
     if (U_FAILURE(errorCode)) {
         log_err("ubidi_setPara failed for multiparaTestString\n");
         ubidi_close(pBidi);
         return;
     }
     gotLevels = ubidi_getLevels(pBidi, &errorCode);
     if (U_FAILURE(errorCode)) {
         log_err("ubidi_getLevels failed for multiparaTestString\n");
         ubidi_close(pBidi);
         return;
     }
-    for (i = 0; i < LENGTHOF(multiparaTestString); i++) {
+    for (i = 0; i < UPRV_LENGTHOF(multiparaTestString); i++) {
         if (gotLevels[i] != multiparaTestLevels[i]) {
             log_err("Error on level for multiparaTestString at index %d, "
                     "expected=%d, actual=%d\n",
                     i, multiparaTestLevels[i], gotLevels[i]);
         }
     }
     ubidi_close(pBidi);
 
 }
 
 
 /* inverse BiDi ------------------------------------------------------------- */
 
 static int countRoundtrips=0, countNonRoundtrips=0;
 
-#define STRING_TEST_CASE(s) { (s), LENGTHOF(s) }
+#define STRING_TEST_CASE(s) { (s), UPRV_LENGTHOF(s) }
 
 static void
 testInverse(void) {
     static const UChar
         string0[]={ 0x6c, 0x61, 0x28, 0x74, 0x69, 0x6e, 0x20, 0x5d0, 0x5d1, 0x29, 0x5d2, 0x5d3 },
         string1[]={ 0x6c, 0x61, 0x74, 0x20, 0x5d0, 0x5d1, 0x5d2, 0x20, 0x31, 0x32, 0x33 },
         string2[]={ 0x6c, 0x61, 0x74, 0x20, 0x5d0, 0x28, 0x5d1, 0x5d2, 0x20, 0x31, 0x29, 0x32, 0x33 },
         string3[]={ 0x31, 0x32, 0x33, 0x20, 0x5d0, 0x5d1, 0x5d2, 0x20, 0x34, 0x35, 0x36 },
         string4[]={ 0x61, 0x62, 0x20, 0x61, 0x62, 0x20, 0x661, 0x662 };
 
@@ skipping 12 matching lines @@
     UErrorCode errorCode;
     int i;
 
     log_verbose("\nEntering TestInverse\n\n");
     pBiDi=ubidi_open();
     if(pBiDi==NULL) {
         log_err("unable to open a UBiDi object (out of memory)\n");
         return;
     }
 
-    log_verbose("inverse Bidi: testInverse(L) with %u test cases ---\n", LENGTHOF(testCases));
-     for(i=0; i<LENGTHOF(testCases); ++i) {
+    log_verbose("inverse Bidi: testInverse(L) with %u test cases ---\n", UPRV_LENGTHOF(testCases));
+     for(i=0; i<UPRV_LENGTHOF(testCases); ++i) {
         log_verbose("Testing case %d\n", i);
         errorCode=U_ZERO_ERROR;
         _testInverseBidi(pBiDi, testCases[i].s, testCases[i].length, 0, &errorCode);
     }
 
-    log_verbose("inverse Bidi: testInverse(R) with %u test cases ---\n", LENGTHOF(testCases));
-    for(i=0; i<LENGTHOF(testCases); ++i) {
+    log_verbose("inverse Bidi: testInverse(R) with %u test cases ---\n", UPRV_LENGTHOF(testCases));
+    for(i=0; i<UPRV_LENGTHOF(testCases); ++i) {
         log_verbose("Testing case %d\n", i);
         errorCode=U_ZERO_ERROR;
         _testInverseBidi(pBiDi, testCases[i].s, testCases[i].length, 1, &errorCode);
     }
 
     _testManyInverseBidi(pBiDi, 0);
     _testManyInverseBidi(pBiDi, 1);
 
     ubidi_close(pBiDi);
 
@@ skipping 56 matching lines @@
 
         /* convert visual to logical */
         ubidi_setInverse(pBiDi, TRUE);
         if (!ubidi_isInverse(pBiDi)) {
             log_err("Error while doing ubidi_setInverse(TRUE)\n");
         }
         ubidi_setPara(pBiDi, src, srcLength, 0, NULL, pErrorCode);
         if (src != ubidi_getText(pBiDi)) {
             log_err("Wrong value returned by ubidi_getText\n");
         }
-        logicalLength=ubidi_writeReordered(pBiDi, logicalDest, LENGTHOF(logicalDest),
+        logicalLength=ubidi_writeReordered(pBiDi, logicalDest, UPRV_LENGTHOF(logicalDest),
                                            UBIDI_DO_MIRRORING|UBIDI_INSERT_LRM_FOR_NUMERIC, pErrorCode);
         log_verbose("  v ");
         printUnicode(src, srcLength, ubidi_getLevels(pBiDi, pErrorCode));
         log_verbose("\n");
 
         /* convert back to visual LTR */
         ubidi_setInverse(pBiDi, FALSE);
         if (ubidi_isInverse(pBiDi)) {
             log_err("Error while doing ubidi_setInverse(FALSE)\n");
         }
         ubidi_setPara(pBiDi, logicalDest, logicalLength, 0, NULL, pErrorCode);
-        visualLength=ubidi_writeReordered(pBiDi, visualDest, LENGTHOF(visualDest),
+        visualLength=ubidi_writeReordered(pBiDi, visualDest, UPRV_LENGTHOF(visualDest),
                                           UBIDI_DO_MIRRORING|UBIDI_REMOVE_BIDI_CONTROLS, pErrorCode);
     } else {
         log_verbose("inverse Bidi: testInverse(R)\n");
 
         /* reverse visual from RTL to LTR */
-        ltrLength=ubidi_writeReverse(src, srcLength, visualLTR, LENGTHOF(visualLTR), 0, pErrorCode);
+        ltrLength=ubidi_writeReverse(src, srcLength, visualLTR, UPRV_LENGTHOF(visualLTR), 0, pErrorCode);
         log_verbose("  vr");
         printUnicode(src, srcLength, NULL);
         log_verbose("\n");
 
         /* convert visual RTL to logical */
         ubidi_setInverse(pBiDi, TRUE);
         ubidi_setPara(pBiDi, visualLTR, ltrLength, 0, NULL, pErrorCode);
-        logicalLength=ubidi_writeReordered(pBiDi, logicalDest, LENGTHOF(logicalDest),
+        logicalLength=ubidi_writeReordered(pBiDi, logicalDest, UPRV_LENGTHOF(logicalDest),
                                            UBIDI_DO_MIRRORING|UBIDI_INSERT_LRM_FOR_NUMERIC, pErrorCode);
         log_verbose("  vl");
         printUnicode(visualLTR, ltrLength, ubidi_getLevels(pBiDi, pErrorCode));
         log_verbose("\n");
 
         /* convert back to visual RTL */
         ubidi_setInverse(pBiDi, FALSE);
         ubidi_setPara(pBiDi, logicalDest, logicalLength, 0, NULL, pErrorCode);
-        visualLength=ubidi_writeReordered(pBiDi, visualDest, LENGTHOF(visualDest),
+        visualLength=ubidi_writeReordered(pBiDi, visualDest, UPRV_LENGTHOF(visualDest),
                                           UBIDI_DO_MIRRORING|UBIDI_REMOVE_BIDI_CONTROLS|UBIDI_OUTPUT_REVERSE, pErrorCode);
     }
     log_verbose("  l ");
     printUnicode(logicalDest, logicalLength, ubidi_getLevels(pBiDi, pErrorCode));
     log_verbose("\n");
     log_verbose("  v ");
     printUnicode(visualDest, visualLength, NULL);
     log_verbose("\n");
 
     /* check and print results */
@@ skipping 20 matching lines @@
         0x29, 0x31, 0x28, 0x20, 0x627, 0x64e, 0x650, 0x200f
     }, reverseRemoveControlsKeepCombiningDoMirror[]={
         0x28, 0x31, 0x29, 0x20, 0x627, 0x64e, 0x650
     };
     UChar reverse[10];
     UErrorCode errorCode;
     int32_t length;
 
     /* test ubidi_writeReverse() with "interesting" options */
     errorCode=U_ZERO_ERROR;
-    length=ubidi_writeReverse(forward, LENGTHOF(forward),
-                              reverse, LENGTHOF(reverse),
+    length=ubidi_writeReverse(forward, UPRV_LENGTHOF(forward),
+                              reverse, UPRV_LENGTHOF(reverse),
                               UBIDI_KEEP_BASE_COMBINING,
                               &errorCode);
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(reverseKeepCombining) || memcmp(reverse, reverseKeepCombining, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(reverseKeepCombining) || memcmp(reverse, reverseKeepCombining, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in ubidi_writeReverse(UBIDI_KEEP_BASE_COMBINING): length=%d (should be %d), error code %s\n",
-                length, LENGTHOF(reverseKeepCombining), u_errorName(errorCode));
+                length, UPRV_LENGTHOF(reverseKeepCombining), u_errorName(errorCode));
     }
 
-    memset(reverse, 0xa5, LENGTHOF(reverse)*U_SIZEOF_UCHAR);
+    memset(reverse, 0xa5, UPRV_LENGTHOF(reverse)*U_SIZEOF_UCHAR);
     errorCode=U_ZERO_ERROR;
-    length=ubidi_writeReverse(forward, LENGTHOF(forward),
-                              reverse, LENGTHOF(reverse),
+    length=ubidi_writeReverse(forward, UPRV_LENGTHOF(forward),
+                              reverse, UPRV_LENGTHOF(reverse),
                               UBIDI_REMOVE_BIDI_CONTROLS|UBIDI_DO_MIRRORING|UBIDI_KEEP_BASE_COMBINING,
                               &errorCode);
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(reverseRemoveControlsKeepCombiningDoMirror) || memcmp(reverse, reverseRemoveControlsKeepCombiningDoMirror, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(reverseRemoveControlsKeepCombiningDoMirror) || memcmp(reverse, reverseRemoveControlsKeepCombiningDoMirror, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in ubidi_writeReverse(UBIDI_REMOVE_BIDI_CONTROLS|UBIDI_DO_MIRRORING|UBIDI_KEEP_BASE_COMBINING):\n"
                 "    length=%d (should be %d), error code %s\n",
-                length, LENGTHOF(reverseRemoveControlsKeepCombiningDoMirror), u_errorName(errorCode));
+                length, UPRV_LENGTHOF(reverseRemoveControlsKeepCombiningDoMirror), u_errorName(errorCode));
     }
 }
 
 static void _testManyAddedPoints(void) {
     UErrorCode errorCode = U_ZERO_ERROR;
     UBiDi *bidi = ubidi_open();
     UChar text[90], dest[MAXLEN], expected[120];
     int destLen, i;
-    for (i = 0; i < LENGTHOF(text); i+=3) {
+    for (i = 0; i < UPRV_LENGTHOF(text); i+=3) {
         text[i] = 0x0061; /* 'a' */
         text[i+1] = 0x05d0;
         text[i+2] = 0x0033; /* '3' */
     }
     ubidi_setReorderingMode(bidi, UBIDI_REORDER_INVERSE_LIKE_DIRECT);
     ubidi_setReorderingOptions(bidi, UBIDI_OPTION_INSERT_MARKS);
-    ubidi_setPara(bidi, text, LENGTHOF(text), UBIDI_LTR, NULL, &errorCode);
+    ubidi_setPara(bidi, text, UPRV_LENGTHOF(text), UBIDI_LTR, NULL, &errorCode);
     destLen = ubidi_writeReordered(bidi, dest, MAXLEN, 0, &errorCode);
-    for (i = 0; i < LENGTHOF(expected); i+=4) {
+    for (i = 0; i < UPRV_LENGTHOF(expected); i+=4) {
         expected[i] = 0x0061; /* 'a' */
         expected[i+1] = 0x05d0;
         expected[i+2] = 0x200e;
         expected[i+3] = 0x0033; /* '3' */
     }
     if (memcmp(dest, expected, destLen * sizeof(UChar))) {
         log_err("\nInvalid output with many added points, "
                 "expected '%s', got '%s'\n",
-                aescstrdup(expected, LENGTHOF(expected)),
+                aescstrdup(expected, UPRV_LENGTHOF(expected)),
                 aescstrdup(dest, destLen));
     }
     ubidi_close(bidi);
 }
 
 static void _testMisc(void) {
     UErrorCode errorCode = U_ZERO_ERROR;
     UBiDi *bidi = ubidi_open();
     UChar src[3], dest[MAXLEN], expected[5];
     int destLen;
     ubidi_setInverse(bidi, TRUE);
     src[0] = src[1] = src[2] = 0x0020;
-    ubidi_setPara(bidi, src, LENGTHOF(src), UBIDI_RTL, NULL, &errorCode);
+    ubidi_setPara(bidi, src, UPRV_LENGTHOF(src), UBIDI_RTL, NULL, &errorCode);
     destLen = ubidi_writeReordered(bidi, dest, MAXLEN,
               UBIDI_OUTPUT_REVERSE | UBIDI_INSERT_LRM_FOR_NUMERIC,
               &errorCode);
     u_unescape("\\u200f   \\u200f", expected, 5);
     if (memcmp(dest, expected, destLen * sizeof(UChar))) {
         log_err("\nInvalid output with RLM at both sides, "
                 "expected '%s', got '%s'\n",
-                aescstrdup(expected, LENGTHOF(expected)),
+                aescstrdup(expected, UPRV_LENGTHOF(expected)),
                 aescstrdup(dest, destLen));
     }
     ubidi_close(bidi);
 }
 
 /* arabic shaping ----------------------------------------------------------- */
 
 static void
 doArabicShapingTest(void) {
     static const UChar
@@ skipping 21 matching lines @@
         0xfefb, 0
     };
     UChar dest[8];
     UErrorCode errorCode;
     int32_t length;
 
     /* test number shaping */
 
     /* european->arabic */
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
                          &errorCode);
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, en2an, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(source) || memcmp(dest, en2an, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(en2an)\n");
     }
 
     /* arabic->european */
     errorCode=U_ZERO_ERROR;
     length=u_shapeArabic(source, -1,
-                         dest, LENGTHOF(dest),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_DIGITS_AN2EN|U_SHAPE_DIGIT_TYPE_AN_EXTENDED,
                          &errorCode);
     if(U_FAILURE(errorCode) || length!=u_strlen(source) || memcmp(dest, an2en, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(an2en)\n");
     }
 
     /* european->arabic with context, logical order, initial state not AL */
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_DIGITS_ALEN2AN_INIT_LR|U_SHAPE_DIGIT_TYPE_AN,
                          &errorCode);
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, logical_alen2an_init_lr, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(source) || memcmp(dest, logical_alen2an_init_lr, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(logical_alen2an_init_lr)\n");
     }
 
     /* european->arabic with context, logical order, initial state AL */
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_DIGITS_ALEN2AN_INIT_AL|U_SHAPE_DIGIT_TYPE_AN_EXTENDED,
                          &errorCode);
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, logical_alen2an_init_al, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(source) || memcmp(dest, logical_alen2an_init_al, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(logical_alen2an_init_al)\n");
     }
 
     /* european->arabic with context, reverse order, initial state not AL */
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_DIGITS_ALEN2AN_INIT_LR|U_SHAPE_DIGIT_TYPE_AN|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, reverse_alen2an_init_lr, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(source) || memcmp(dest, reverse_alen2an_init_lr, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(reverse_alen2an_init_lr)\n");
     }
 
     /* european->arabic with context, reverse order, initial state AL */
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_DIGITS_ALEN2AN_INIT_AL|U_SHAPE_DIGIT_TYPE_AN_EXTENDED|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, reverse_alen2an_init_al, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(source) || memcmp(dest, reverse_alen2an_init_al, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(reverse_alen2an_init_al)\n");
     }
 
     /* test noop */
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          0,
                          &errorCode);
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(source) || memcmp(dest, source, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(source) || memcmp(dest, source, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(noop)\n");
     }
 
     errorCode=U_ZERO_ERROR;
     length=u_shapeArabic(source, 0,
-                         dest, LENGTHOF(dest),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
                          &errorCode);
     if(U_FAILURE(errorCode) || length!=0) {
-        log_err("failure in u_shapeArabic(en2an, sourceLength=0), returned %d/%s\n", u_errorName(errorCode), LENGTHOF(source));
+        log_err("failure in u_shapeArabic(en2an, sourceLength=0), returned %d/%s\n", u_errorName(errorCode), UPRV_LENGTHOF(source));
     }
 
     /* preflight digit shaping */
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(source, LENGTHOF(source),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
                          NULL, 0,
                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
                          &errorCode);
-    if(errorCode!=U_BUFFER_OVERFLOW_ERROR || length!=LENGTHOF(source)) {
+    if(errorCode!=U_BUFFER_OVERFLOW_ERROR || length!=UPRV_LENGTHOF(source)) {
         log_err("failure in u_shapeArabic(en2an preflighting), returned %d/%s instead of %d/U_BUFFER_OVERFLOW_ERROR\n",
-                length, u_errorName(errorCode), LENGTHOF(source));
+                length, u_errorName(errorCode), UPRV_LENGTHOF(source));
     }
 
     /* test illegal arguments */
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(NULL, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(NULL, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
                          &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
         log_err("failure in u_shapeArabic(source=NULL), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
     }
 
     errorCode=U_ZERO_ERROR;
     length=u_shapeArabic(source, -2,
-                         dest, LENGTHOF(dest),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
                          &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
         log_err("failure in u_shapeArabic(sourceLength=-2), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
     }
 
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         NULL, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         NULL, UPRV_LENGTHOF(dest),
                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
                          &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
         log_err("failure in u_shapeArabic(dest=NULL), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
     }
 
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(source, LENGTHOF(source),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
                          dest, -1,
                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
                          &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
         log_err("failure in u_shapeArabic(destSize=-1), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
     }
 
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_DIGITS_RESERVED|U_SHAPE_DIGIT_TYPE_AN,
                          &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
         log_err("failure in u_shapeArabic(U_SHAPE_DIGITS_RESERVED), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
     }
 
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_RESERVED,
                          &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
         log_err("failure in u_shapeArabic(U_SHAPE_DIGIT_TYPE_RESERVED), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
     }
 
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         (UChar *)(source+2), LENGTHOF(dest), /* overlap source and destination */
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         (UChar *)(source+2), UPRV_LENGTHOF(dest), /* overlap source and destination */
                          U_SHAPE_DIGITS_EN2AN|U_SHAPE_DIGIT_TYPE_AN,
                          &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
         log_err("failure in u_shapeArabic(U_SHAPE_DIGIT_TYPE_RESERVED), returned %s instead of U_ILLEGAL_ARGUMENT_ERROR\n", u_errorName(errorCode));
     }
 
     errorCode=U_ZERO_ERROR;
-    length=u_shapeArabic(lamalef, LENGTHOF(lamalef),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(lamalef, UPRV_LENGTHOF(lamalef),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_UNSHAPE | U_SHAPE_LENGTH_GROW_SHRINK | U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
-    if(U_FAILURE(errorCode) || length == LENGTHOF(lamalef)) {
+    if(U_FAILURE(errorCode) || length == UPRV_LENGTHOF(lamalef)) {
         log_err("failure in u_shapeArabic(U_SHAPE_LETTERS_UNSHAPE | U_SHAPE_LENGTH_GROW_SHRINK | U_SHAPE_TEXT_DIRECTION_VISUAL_LTR)\n");
         log_err("returned %s instead of U_ZERO_ERROR or returned length %d instead of 3\n", u_errorName(errorCode), length);
     }
 }
 
 static void
 doLamAlefSpecialVLTRArabicShapingTest(void) {
     static const UChar
     source[]={
 /*a*/   0x20 ,0x646,0x622,0x644,0x627,0x20,
@@ skipping 39 matching lines @@
         0xfefb,0xfe8d,0x20,0xfee5,0x653,0xfef5,0xfe8d,0x20,0xfee5,0x655,0xfef9,0xfe8d,
         0x20,0xfee5,0x654,0xfef5,0xfe8d,0x20,0xfefc,0xfecb
     };
 
     UChar dest[38];
     UErrorCode errorCode;
     int32_t length;
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_NEAR|
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_near) || memcmp(dest, shape_near, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_near) || memcmp(dest, shape_near, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(LAMALEF shape_near)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_END|
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_at_end) || memcmp(dest, shape_at_end, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_at_end) || memcmp(dest, shape_at_end, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(LAMALEF shape_at_end)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_BEGINNING|
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_at_begin) || memcmp(dest, shape_at_begin, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_at_begin) || memcmp(dest, shape_at_begin, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(LAMALEF shape_at_begin)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_GROW_SHRINK|
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
     if(U_FAILURE(errorCode) || memcmp(dest, shape_grow_shrink, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(LAMALEF shape_grow_shrink)\n");
     }
 
     /* ==================== U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED ==================== */
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_FIXED_SPACES_NEAR|
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_excepttashkeel_near) || memcmp(dest, shape_excepttashkeel_near, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_excepttashkeel_near) || memcmp(dest, shape_excepttashkeel_near, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_near)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_FIXED_SPACES_AT_END|
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_excepttashkeel_at_end) || memcmp(dest,shape_excepttashkeel_at_end , length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_excepttashkeel_at_end) || memcmp(dest,shape_excepttashkeel_at_end , length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_at_end)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_FIXED_SPACES_AT_BEGINNING|
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_excepttashkeel_at_begin) || memcmp(dest, shape_excepttashkeel_at_begin, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_excepttashkeel_at_begin) || memcmp(dest, shape_excepttashkeel_at_begin, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_at_begin)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_GROW_SHRINK|
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
     if(U_FAILURE(errorCode) || memcmp(dest, shape_excepttashkeel_grow_shrink, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(LAMALEF shape_excepttashkeel_grow_shrink)\n");
     }
 }
 
 static void
@@ skipping 18 matching lines @@
         0x20,0xfe8f,0x653,0xfeae,0x653,0xfecb,0x20,0xfe8f,0x654,0xfeae,0x654,0xfecb,0x20,
         0xfe8f,0x655,0xfeae,0x655,0xfecb,0x20
     };
 
     UChar dest[43];
     UErrorCode errorCode;
     int32_t length;
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_LENGTH_FIXED_SPACES_NEAR|
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_near) || memcmp(dest, shape_near, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_near) || memcmp(dest, shape_near, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(TASHKEEL shape_near)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_LENGTH_FIXED_SPACES_NEAR|
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(shape_excepttashkeel_near) || memcmp(dest, shape_excepttashkeel_near, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(shape_excepttashkeel_near) || memcmp(dest, shape_excepttashkeel_near, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(TASHKEEL shape_excepttashkeel_near)\n");
     }
 }
 
 static void
 doLOGICALArabicDeShapingTest(void) {
     static const UChar
     source[]={
         0x0020,0x0020,0x0020,0xFE8D,0xFEF5,0x0020,0xFEE5,0x0020,0xFE8D,0xFEF7,0x0020,
         0xFED7,0xFEFC,0x0020,0xFEE1,0x0020,0xFE8D,0xFEDF,0xFECC,0xFEAE,0xFE91,0xFEF4,
@@ skipping 15 matching lines @@
         0x644,0x627,0x20,0x645,0x20,0x627,0x644,0x639,0x631,0x628,0x64a,0x629,0x20,0x627,
         0x644,0x62d,0x631,0x629,0x20,0x20,0x20,0x20
     };
 
     UChar dest[36];
     UErrorCode errorCode;
     int32_t length;
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_FIXED_SPACES_NEAR|
                          U_SHAPE_TEXT_DIRECTION_LOGICAL,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(unshape_near) || memcmp(dest, unshape_near, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(unshape_near) || memcmp(dest, unshape_near, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(unshape_near)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_END|
                          U_SHAPE_TEXT_DIRECTION_LOGICAL,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(unshape_at_end) || memcmp(dest, unshape_at_end, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(unshape_at_end) || memcmp(dest, unshape_at_end, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(unshape_at_end)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_FIXED_SPACES_AT_BEGINNING|
                          U_SHAPE_TEXT_DIRECTION_LOGICAL,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(unshape_at_begin) || memcmp(dest, unshape_at_begin, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(unshape_at_begin) || memcmp(dest, unshape_at_begin, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(unshape_at_begin)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(source, LENGTHOF(source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(source, UPRV_LENGTHOF(source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_UNSHAPE|U_SHAPE_LENGTH_GROW_SHRINK|
                          U_SHAPE_TEXT_DIRECTION_LOGICAL,
                          &errorCode);
 
     if(U_FAILURE(errorCode) || memcmp(dest, unshape_grow_shrink, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(unshape_grow_shrink)\n");
     }
 
 }
 
 static void
 doTailTest(void) {
   static const UChar src[] = { 0x0020, 0x0633, 0 };
   static const UChar dst_old[] = { 0xFEB1, 0x200B,0 };
   static const UChar dst_new[] = { 0xFEB1, 0xFE73,0 };
   UChar dst[3] = { 0x0000, 0x0000,0 };
   int32_t length;
   UErrorCode status;
 
   log_verbose("SRC: U+%04X U+%04X\n", src[0],src[1]);
 
   log_verbose("Trying old tail\n");
   status = U_ZERO_ERROR;
-  length = u_shapeArabic(src, -1, dst, LENGTHOF(dst),
+  length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR, &status);
   if(U_FAILURE(status)) {
     log_err("Fail: status %s\n", u_errorName(status));
   } else if(length!=2) {
     log_err("Fail: len %d expected 3\n", length);
-  } else if(u_strncmp(dst,dst_old,LENGTHOF(dst))) {
+  } else if(u_strncmp(dst,dst_old,UPRV_LENGTHOF(dst))) {
     log_err("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
             dst[0],dst[1],dst_old[0],dst_old[1]);
   } else {
     log_verbose("OK:  U+%04X U+%04X len %d err %s\n",
             dst[0],dst[1],length,u_errorName(status));
   }
 
 
   log_verbose("Trying new tail\n");
   status = U_ZERO_ERROR;
-  length = u_shapeArabic(src, -1, dst, LENGTHOF(dst),
+  length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR|U_SHAPE_TAIL_NEW_UNICODE, &status);
   if(U_FAILURE(status)) {
     log_err("Fail: status %s\n", u_errorName(status));
   } else if(length!=2) {
     log_err("Fail: len %d expected 3\n", length);
-  } else if(u_strncmp(dst,dst_new,LENGTHOF(dst))) {
+  } else if(u_strncmp(dst,dst_new,UPRV_LENGTHOF(dst))) {
     log_err("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
             dst[0],dst[1],dst_new[0],dst_new[1]);
   } else {
     log_verbose("OK:  U+%04X U+%04X len %d err %s\n",
             dst[0],dst[1],length,u_errorName(status));
   }
 }
 
 static void
 doArabicShapingTestForBug5421(void) {
@@ skipping 17 matching lines @@
     }, untouched_presentation_r[]={
         0x0020, 0xfe90,0xfe8D,0x0020
     };
 
     UChar dest[38];
     UErrorCode errorCode;
     int32_t length;
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(persian_letters_source, LENGTHOF(persian_letters_source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(persian_letters_source, UPRV_LENGTHOF(persian_letters_source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(persian_letters) || memcmp(dest, persian_letters, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(persian_letters) || memcmp(dest, persian_letters, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(persian_letters)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(tashkeel_aggregation_source, LENGTHOF(tashkeel_aggregation_source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(tashkeel_aggregation_source, UPRV_LENGTHOF(tashkeel_aggregation_source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_AGGREGATE_TASHKEEL|U_SHAPE_PRESERVE_PRESENTATION|
                          U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(tashkeel_aggregation) || memcmp(dest, tashkeel_aggregation, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(tashkeel_aggregation) || memcmp(dest, tashkeel_aggregation, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(tashkeel_aggregation)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(untouched_presentation_source, LENGTHOF(untouched_presentation_source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(untouched_presentation_source, UPRV_LENGTHOF(untouched_presentation_source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_PRESERVE_PRESENTATION|
                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_TEXT_DIRECTION_VISUAL_LTR,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(untouched_presentation) || memcmp(dest, untouched_presentation, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(untouched_presentation) || memcmp(dest, untouched_presentation, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(untouched_presentation)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(untouched_presentation_r_source, LENGTHOF(untouched_presentation_r_source),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(untouched_presentation_r_source, UPRV_LENGTHOF(untouched_presentation_r_source),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_PRESERVE_PRESENTATION|
                          U_SHAPE_LETTERS_SHAPE|U_SHAPE_TEXT_DIRECTION_LOGICAL,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(untouched_presentation_r) || memcmp(dest, untouched_presentation_r, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(untouched_presentation_r) || memcmp(dest, untouched_presentation_r, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(untouched_presentation_r)\n");
     }
 }
 
 static void
 doArabicShapingTestForBug8703(void) {
     static const UChar
     letters_source1[]={
         0x0634,0x0651,0x0645,0x0652,0x0633
     }, letters_source2[]={
@@ skipping 27 matching lines @@
     }, letters_dest8[]={
         0xFEB2,0x0640,0xFEE4,0xFE7D,0xFEB7
     };
 
     UChar dest[20];
     UErrorCode errorCode;
     int32_t length;
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source1, LENGTHOF(letters_source1),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source1, UPRV_LENGTHOF(letters_source1),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_BEGIN | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest1) || memcmp(dest, letters_dest1, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest1) || memcmp(dest, letters_dest1, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source1)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source2, LENGTHOF(letters_source2),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source2, UPRV_LENGTHOF(letters_source2),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_END | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest2) || memcmp(dest, letters_dest2, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest2) || memcmp(dest, letters_dest2, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source2)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source3, LENGTHOF(letters_source3),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source3, UPRV_LENGTHOF(letters_source3),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_RESIZE | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest3) || memcmp(dest, letters_dest3, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest3) || memcmp(dest, letters_dest3, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source3)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source4, LENGTHOF(letters_source4),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source4, UPRV_LENGTHOF(letters_source4),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_REPLACE_BY_TATWEEL | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest4) || memcmp(dest, letters_dest4, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest4) || memcmp(dest, letters_dest4, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source4)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source5, LENGTHOF(letters_source5),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source5, UPRV_LENGTHOF(letters_source5),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_BEGIN | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest5) || memcmp(dest, letters_dest5, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest5) || memcmp(dest, letters_dest5, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source5)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source6, LENGTHOF(letters_source6),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source6, UPRV_LENGTHOF(letters_source6),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_END | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest6) || memcmp(dest, letters_dest6, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest6) || memcmp(dest, letters_dest6, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source6)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source7, LENGTHOF(letters_source7),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source7, UPRV_LENGTHOF(letters_source7),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_RESIZE | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest7) || memcmp(dest, letters_dest7, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest7) || memcmp(dest, letters_dest7, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source7)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source8, LENGTHOF(letters_source8),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source8, UPRV_LENGTHOF(letters_source8),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_REPLACE_BY_TATWEEL | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest8) || memcmp(dest, letters_dest8, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest8) || memcmp(dest, letters_dest8, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source8)\n");
     }
 }
 
 static void
 doArabicShapingTestForBug9024(void) {
     static const UChar
     letters_source1[]={  /* Arabic mathematical Symbols 0x1EE00 - 0x1EE1B */
         0xD83B, 0xDE00, 0xD83B, 0xDE01, 0xD83B, 0xDE02, 0xD83B, 0xDE03, 0x20,
         0xD83B, 0xDE24, 0xD83B, 0xDE05, 0xD83B, 0xDE06, 0x20,
@@ skipping 79 matching lines @@
     }, letters_dest6[]={
         0xD83B, 0xDE21, 0xFEB1, 0xD83B, 0xDE62, 0xFEE9
     };
 
     UChar dest[MAXLEN];
     UErrorCode errorCode;
     int32_t length;
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source1, LENGTHOF(letters_source1),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source1, UPRV_LENGTHOF(letters_source1),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_BEGIN | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest1) || memcmp(dest, letters_dest1, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest1) || memcmp(dest, letters_dest1, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source1)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source2, LENGTHOF(letters_source2),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source2, UPRV_LENGTHOF(letters_source2),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_END | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest2) || memcmp(dest, letters_dest2, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest2) || memcmp(dest, letters_dest2, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source2)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source3, LENGTHOF(letters_source3),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source3, UPRV_LENGTHOF(letters_source3),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_RESIZE | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest3) || memcmp(dest, letters_dest3, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest3) || memcmp(dest, letters_dest3, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source3)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source4, LENGTHOF(letters_source4),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source4, UPRV_LENGTHOF(letters_source4),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_RTL | U_SHAPE_TASHKEEL_REPLACE_BY_TATWEEL | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest4) || memcmp(dest, letters_dest4, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest4) || memcmp(dest, letters_dest4, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source4)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source5, LENGTHOF(letters_source5),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source5, UPRV_LENGTHOF(letters_source5),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_BEGIN | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest5) || memcmp(dest, letters_dest5, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest5) || memcmp(dest, letters_dest5, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source5)\n");
     }
 
     errorCode=U_ZERO_ERROR;
 
-    length=u_shapeArabic(letters_source6, LENGTHOF(letters_source6),
-                         dest, LENGTHOF(dest),
+    length=u_shapeArabic(letters_source6, UPRV_LENGTHOF(letters_source6),
+                         dest, UPRV_LENGTHOF(dest),
                          U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_TASHKEEL_END | U_SHAPE_LETTERS_SHAPE,
                          &errorCode);
 
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(letters_dest6) || memcmp(dest, letters_dest6, length*U_SIZEOF_UCHAR)!=0) {
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(letters_dest6) || memcmp(dest, letters_dest6, length*U_SIZEOF_UCHAR)!=0) {
         log_err("failure in u_shapeArabic(letters_source6)\n");
     }
 
 }
 
+static void _testPresentationForms(const UChar* in) {
+  enum Forms { GENERIC, ISOLATED, FINAL, INITIAL, MEDIAL };
+  /* This character is used to check whether the in-character is rewritten correctly
+     and whether the surrounding characters are shaped correctly as well. */
+  UChar otherChar[] = {0x0628, 0xfe8f, 0xfe90, 0xfe91, 0xfe92};
+  UChar src[3];
+  UChar dst[3];
+  UErrorCode errorCode;
+  int32_t length;
+
+  /* Testing isolated shaping */
+  src[0] = in[GENERIC];
+  errorCode=U_ZERO_ERROR;
+  length=u_shapeArabic(src, 1,
+                       dst, 1,
+                       U_SHAPE_LETTERS_SHAPE,
+                       &errorCode);
+  if(U_FAILURE(errorCode) || length!=1 || dst[0] != in[ISOLATED]) {
+      log_err("failure in u_shapeArabic(_testAllForms: shaping isolated): %x\n", in[GENERIC]);
+  }
+  errorCode=U_ZERO_ERROR;
+  length=u_shapeArabic(dst, 1,
+                       src, 1,
+                       U_SHAPE_LETTERS_UNSHAPE,
+                       &errorCode);
+  if(U_FAILURE(errorCode) || length!=1 || src[0] != in[GENERIC]) {
+      log_err("failure in u_shapeArabic(_testAllForms: unshaping isolated): %x\n", in[GENERIC]);
+  }
+
+  /* Testing final shaping */
+  src[0] = otherChar[GENERIC];
+  src[1] = in[GENERIC];
+  if (in[FINAL] != 0) {
+    errorCode=U_ZERO_ERROR;
+    length=u_shapeArabic(src, 2,
+                         dst, 2,
+                         U_SHAPE_LETTERS_SHAPE,
+                         &errorCode);
+    if(U_FAILURE(errorCode) || length!=2 || dst[0] != otherChar[INITIAL] || dst[1] != in[FINAL]) {
+      log_err("failure in u_shapeArabic(_testAllForms: shaping final): %x\n", in[GENERIC]);
+    }
+    errorCode=U_ZERO_ERROR;
+    length=u_shapeArabic(dst, 2,
+                         src, 2,
+                         U_SHAPE_LETTERS_UNSHAPE,
+                         &errorCode);
+    if(U_FAILURE(errorCode) || length!=2 || src[0] != otherChar[GENERIC] || src[1] != in[GENERIC]) {
+      log_err("failure in u_shapeArabic(_testAllForms: unshaping final): %x\n", in[GENERIC]);
+    }
+  } else {
+    errorCode=U_ZERO_ERROR;
+    length=u_shapeArabic(src, 2,
+                         dst, 2,
+                         U_SHAPE_LETTERS_SHAPE,
+                         &errorCode);
+    if(U_FAILURE(errorCode) || length!=2 || dst[0] != otherChar[ISOLATED] || dst[1] != in[ISOLATED]) {
+      log_err("failure in u_shapeArabic(_testAllForms: shaping final): %x\n", in[GENERIC]);
+    }
+    errorCode=U_ZERO_ERROR;
+    length=u_shapeArabic(dst, 2,
+                         src, 2,
+                         U_SHAPE_LETTERS_UNSHAPE,
+                         &errorCode);
+    if(U_FAILURE(errorCode) || length!=2 || src[0] != otherChar[GENERIC] || src[1] != in[GENERIC]) {
+      log_err("failure in u_shapeArabic(_testAllForms: unshaping final): %x\n", in[GENERIC]);
+    }
+  }
+
+  /* Testing initial shaping */
+  src[0] = in[GENERIC];
+  src[1] = otherChar[GENERIC];
+  if (in[INITIAL] != 0) {
+    /* Testing characters that have an initial form */
+    errorCode=U_ZERO_ERROR;
+    length=u_shapeArabic(src, 2,
+                         dst, 2,
+                         U_SHAPE_LETTERS_SHAPE,
+                         &errorCode);
+    if(U_FAILURE(errorCode) || length!=2 || dst[0] != in[INITIAL] || dst[1] != otherChar[FINAL]) {
+      log_err("failure in u_shapeArabic(_testAllForms: shaping initial): %x\n", in[GENERIC]);
+    }
+    errorCode=U_ZERO_ERROR;
+    length=u_shapeArabic(dst, 2,
+                         src, 2,
+                         U_SHAPE_LETTERS_UNSHAPE,
+                         &errorCode);
+    if(U_FAILURE(errorCode) || length!=2 || src[0] != in[GENERIC] || src[1] != otherChar[GENERIC]) {
+      log_err("failure in u_shapeArabic(_testAllForms: unshaping initial): %x\n", in[GENERIC]);
+    }
+  } else {
+    /* Testing characters that do not have an initial form */
+    errorCode=U_ZERO_ERROR;
+    length=u_shapeArabic(src, 2,
+                         dst, 2,
+                         U_SHAPE_LETTERS_SHAPE,
+                         &errorCode);
+    if(U_FAILURE(errorCode) || length!=2 || dst[0] != in[ISOLATED] || dst[1] != otherChar[ISOLATED]) {
+      log_err("failure in u_shapeArabic(_testTwoForms: shaping initial): %x\n", in[GENERIC]);
+    }
+    errorCode=U_ZERO_ERROR;
+    length=u_shapeArabic(dst, 2,
+                         src, 2,
+                         U_SHAPE_LETTERS_UNSHAPE,
+                         &errorCode);
+    if(U_FAILURE(errorCode) || length!=2 || src[0] != in[GENERIC] || src[1] != otherChar[GENERIC]) {
+      log_err("failure in u_shapeArabic(_testTwoForms: unshaping initial): %x\n", in[GENERIC]);
+    }
+  }
+
+  /* Testing medial shaping */
+  src[0] = otherChar[0];
+  src[1] = in[GENERIC];
+  src[2] = otherChar[0];
+  errorCode=U_ZERO_ERROR;
+  if (in[MEDIAL] != 0) {
+    /* Testing characters that have an medial form */
+    length=u_shapeArabic(src, 3,
+                         dst, 3,
+                         U_SHAPE_LETTERS_SHAPE,
+                         &errorCode);
+    if(U_FAILURE(errorCode) || length!=3 || dst[0] != otherChar[INITIAL] || dst[1] != in[MEDIAL] || dst[2] != otherChar[FINAL]) {
+      log_err("failure in u_shapeArabic(_testAllForms: shaping medial): %x\n", in[GENERIC]);
+    }
+    errorCode=U_ZERO_ERROR;
+    length=u_shapeArabic(dst, 3,
+                         src, 3,
+                         U_SHAPE_LETTERS_UNSHAPE,
+                         &errorCode);
+    if(U_FAILURE(errorCode) || length!=3 || src[0] != otherChar[GENERIC] || src[1] != in[GENERIC] || src[2] != otherChar[GENERIC]) {
+      log_err("failure in u_shapeArabic(_testAllForms: unshaping medial): %x\n", in[GENERIC]);
+    }
+  } else {
+    /* Testing characters that do not have an medial form */
+    errorCode=U_ZERO_ERROR;
+    length=u_shapeArabic(src, 3,
+                         dst, 3,
+                         U_SHAPE_LETTERS_SHAPE,
+                         &errorCode);
+    if(U_FAILURE(errorCode) || length!=3 || dst[0] != otherChar[INITIAL] || dst[1] != in[FINAL] || dst[2] != otherChar[ISOLATED]) {
+      log_err("failure in u_shapeArabic(_testTwoForms: shaping medial): %x\n", in[GENERIC]);
+    }
+    errorCode=U_ZERO_ERROR;
+    length=u_shapeArabic(dst, 3,
+                         src, 3,
+                         U_SHAPE_LETTERS_UNSHAPE,
+                         &errorCode);
+    if(U_FAILURE(errorCode) || length!=3 || src[0] != otherChar[GENERIC] || src[1] != in[GENERIC] || src[2] != otherChar[GENERIC]) {
+      log_err("failure in u_shapeArabic(_testTwoForms: unshaping medial): %x\n", in[GENERIC]);
+    }
+  }
+}
+
+static void
+doArabicShapingTestForNewCharacters(void) {
+  static const UChar letterForms[][5]={
+    { 0x0679, 0xFB66, 0xFB67, 0xFB68, 0xFB69 },  /* TTEH */
+    { 0x067A, 0xFB5E, 0xFB5F, 0xFB60, 0xFB61 },  /* TTEHEH */
+    { 0x067B, 0xFB52, 0xFB53, 0xFB54, 0xFB55 },  /* BEEH */
+    { 0x0688, 0xFB88, 0xFB89, 0, 0 },            /* DDAL */
+    { 0x068C, 0xFB84, 0xFB85, 0, 0 },            /* DAHAL */
+    { 0x068D, 0xFB82, 0xFB83, 0, 0 },            /* DDAHAL */
+    { 0x068E, 0xFB86, 0xFB87, 0, 0 },            /* DUL */
+    { 0x0691, 0xFB8C, 0xFB8D, 0, 0 },            /* RREH */
+    { 0x06BA, 0xFB9E, 0xFB9F, 0, 0 },            /* NOON GHUNNA */
+    { 0x06BB, 0xFBA0, 0xFBA1, 0xFBA2, 0xFBA3 },  /* RNOON */
+    { 0x06BE, 0xFBAA, 0xFBAB, 0xFBAC, 0xFBAD },  /* HEH DOACHASHMEE */
+    { 0x06C0, 0xFBA4, 0xFBA5, 0, 0 },            /* HEH WITH YEH ABOVE */
+    { 0x06C1, 0xFBA6, 0xFBA7, 0xFBA8, 0xFBA9 },  /* HEH GOAL */
+    { 0x06C5, 0xFBE0, 0xFBE1, 0, 0 },            /* KIRGIHIZ OE */
+    { 0x06C6, 0xFBD9, 0xFBDA, 0, 0 },            /* OE */
+    { 0x06C7, 0xFBD7, 0xFBD8, 0, 0 },            /* U */
+    { 0x06C8, 0xFBDB, 0xFBDC, 0, 0 },            /* YU */
+    { 0x06C9, 0xFBE2, 0xFBE3, 0, 0 },            /* KIRGIZ YU */
+    { 0x06CB, 0xFBDE, 0xFBDF, 0, 0},             /* VE */
+    { 0x06D0, 0xFBE4, 0xFBE5, 0xFBE6, 0xFBE7 },  /* E */
+    { 0x06D2, 0xFBAE, 0xFBAF, 0, 0 },            /* YEH BARREE */
+    { 0x06D3, 0xFBB0, 0xFBB1, 0, 0 },            /* YEH BARREE WITH HAMZA ABOVE */
+    { 0x0622, 0xFE81, 0xFE82, 0, 0, },           /* ALEF WITH MADDA ABOVE */
+    { 0x0623, 0xFE83, 0xFE84, 0, 0, },           /* ALEF WITH HAMZA ABOVE */
+    { 0x0624, 0xFE85, 0xFE86, 0, 0, },           /* WAW WITH HAMZA ABOVE */
+    { 0x0625, 0xFE87, 0xFE88, 0, 0, },           /* ALEF WITH HAMZA BELOW */
+    { 0x0626, 0xFE89, 0xFE8A, 0xFE8B, 0xFE8C, }, /* YEH WITH HAMZA ABOVE */
+    { 0x0627, 0xFE8D, 0xFE8E, 0, 0, },           /* ALEF */
+    { 0x0628, 0xFE8F, 0xFE90, 0xFE91, 0xFE92, }, /* BEH */
+    { 0x0629, 0xFE93, 0xFE94, 0, 0, },           /* TEH MARBUTA */
+    { 0x062A, 0xFE95, 0xFE96, 0xFE97, 0xFE98, }, /* TEH */
+    { 0x062B, 0xFE99, 0xFE9A, 0xFE9B, 0xFE9C, }, /* THEH */
+    { 0x062C, 0xFE9D, 0xFE9E, 0xFE9F, 0xFEA0, }, /* JEEM */
+    { 0x062D, 0xFEA1, 0xFEA2, 0xFEA3, 0xFEA4, }, /* HAH */
+    { 0x062E, 0xFEA5, 0xFEA6, 0xFEA7, 0xFEA8, }, /* KHAH */
+    { 0x062F, 0xFEA9, 0xFEAA, 0, 0, },           /* DAL */
+    { 0x0630, 0xFEAB, 0xFEAC, 0, 0, },           /* THAL */
+    { 0x0631, 0xFEAD, 0xFEAE, 0, 0, },           /* REH */
+    { 0x0632, 0xFEAF, 0xFEB0, 0, 0, },           /* ZAIN */
+    { 0x0633, 0xFEB1, 0xFEB2, 0xFEB3, 0xFEB4, }, /* SEEN */
+    { 0x0634, 0xFEB5, 0xFEB6, 0xFEB7, 0xFEB8, }, /* SHEEN */
+    { 0x0635, 0xFEB9, 0xFEBA, 0xFEBB, 0xFEBC, }, /* SAD */
+    { 0x0636, 0xFEBD, 0xFEBE, 0xFEBF, 0xFEC0, }, /* DAD */
+    { 0x0637, 0xFEC1, 0xFEC2, 0xFEC3, 0xFEC4, }, /* TAH */
+    { 0x0638, 0xFEC5, 0xFEC6, 0xFEC7, 0xFEC8, }, /* ZAH */
+    { 0x0639, 0xFEC9, 0xFECA, 0xFECB, 0xFECC, }, /* AIN */
+    { 0x063A, 0xFECD, 0xFECE, 0xFECF, 0xFED0, }, /* GHAIN */
+    { 0x0641, 0xFED1, 0xFED2, 0xFED3, 0xFED4, }, /* FEH */
+    { 0x0642, 0xFED5, 0xFED6, 0xFED7, 0xFED8, }, /* QAF */
+    { 0x0643, 0xFED9, 0xFEDA, 0xFEDB, 0xFEDC, }, /* KAF */
+    { 0x0644, 0xFEDD, 0xFEDE, 0xFEDF, 0xFEE0, }, /* LAM */
+    { 0x0645, 0xFEE1, 0xFEE2, 0xFEE3, 0xFEE4, }, /* MEEM */
+    { 0x0646, 0xFEE5, 0xFEE6, 0xFEE7, 0xFEE8, }, /* NOON */
+    { 0x0647, 0xFEE9, 0xFEEA, 0xFEEB, 0xFEEC, }, /* HEH */
+    { 0x0648, 0xFEED, 0xFEEE, 0, 0, },           /* WAW */
+    { 0x0649, 0xFEEF, 0xFEF0, 0, 0, },           /* ALEF MAKSURA */
+    { 0x064A, 0xFEF1, 0xFEF2, 0xFEF3, 0xFEF4, }, /* YEH */
+    { 0x064E, 0xFE76, 0, 0, 0xFE77, },           /* FATHA */
+    { 0x064F, 0xFE78, 0, 0, 0xFE79, },           /* DAMMA */
+    { 0x0650, 0xFE7A, 0, 0, 0xFE7B, },           /* KASRA */
+    { 0x0651, 0xFE7C, 0, 0, 0xFE7D, },           /* SHADDA */
+    { 0x0652, 0xFE7E, 0, 0, 0xFE7F, },           /* SUKUN */
+    { 0x0679, 0xFB66, 0xFB67, 0xFB68, 0xFB69, }, /* TTEH */
+    { 0x067E, 0xFB56, 0xFB57, 0xFB58, 0xFB59, }, /* PEH */
+    { 0x0686, 0xFB7A, 0xFB7B, 0xFB7C, 0xFB7D, }, /* TCHEH */
+    { 0x0688, 0xFB88, 0xFB89, 0, 0, },           /* DDAL */
+    { 0x0691, 0xFB8C, 0xFB8D, 0, 0, },           /* RREH */
+    { 0x0698, 0xFB8A, 0xFB8B, 0, 0, },           /* JEH */
+    { 0x06A9, 0xFB8E, 0xFB8F, 0xFB90, 0xFB91, }, /* KEHEH */
+    { 0x06AF, 0xFB92, 0xFB93, 0xFB94, 0xFB95, }, /* GAF */
+    { 0x06BA, 0xFB9E, 0xFB9F, 0, 0, },           /* NOON GHUNNA */
+    { 0x06BE, 0xFBAA, 0xFBAB, 0xFBAC, 0xFBAD, }, /* HEH DOACHASHMEE */
+    { 0x06C0, 0xFBA4, 0xFBA5, 0, 0, },           /* HEH WITH YEH ABOVE */
+    { 0x06C1, 0xFBA6, 0xFBA7, 0xFBA8, 0xFBA9, }, /* HEH GOAL */
+    { 0x06CC, 0xFBFC, 0xFBFD, 0xFBFE, 0xFBFF, }, /* FARSI YEH */
+    { 0x06D2, 0xFBAE, 0xFBAF, 0, 0, },           /* YEH BARREE */
+    { 0x06D3, 0xFBB0, 0xFBB1, 0, 0, }};          /* YEH BARREE WITH HAMZA ABOVE */
+  int32_t i;
+  for (i = 0; i < UPRV_LENGTHOF(letterForms); ++i) {
+    _testPresentationForms(letterForms[i]);
+  }
+}
+
 /* helpers ------------------------------------------------------------------ */
 
 static void initCharFromDirProps(void) {
     static const UVersionInfo ucd401={ 4, 0, 1, 0 };
     static UVersionInfo ucdVersion={ 0, 0, 0, 0 };
 
     /* lazy initialization */
     if(ucdVersion[0]>0) {
         return;
     }
@@ skipping 92 matching lines @@
 };
 static const struct {
     uint32_t value;
     const char* description;
 }
 options[] = {
     { MAKE_ITEMS(UBIDI_OPTION_INSERT_MARKS) },
     { MAKE_ITEMS(0) }
 };
 
-#define TC_COUNT                LENGTHOF(textIn)
-#define MODES_COUNT             LENGTHOF(modes)
-#define OPTIONS_COUNT           LENGTHOF(options)
-#define LEVELS_COUNT            LENGTHOF(paraLevels)
+#define TC_COUNT                UPRV_LENGTHOF(textIn)
+#define MODES_COUNT             UPRV_LENGTHOF(modes)
+#define OPTIONS_COUNT           UPRV_LENGTHOF(options)
+#define LEVELS_COUNT            UPRV_LENGTHOF(paraLevels)
 
 static const char* const textIn[] = {
 /* (0) 123 */
     "123",
 /* (1) .123->4.5 */
     ".123->4.5",
 /* (2) 678 */
     "678",
 /* (3) .678->8.9 */
     ".678->8.9",
@@ skipping 504 matching lines @@
     if(!pL2VBiDi) {
         ubidi_close(pBiDi);             /* in case this one was allocated */
         return;
     }
     ubidi_setReorderingMode(pBiDi, UBIDI_REORDER_RUNS_ONLY);
     ubidi_setReorderingOptions(pL2VBiDi, UBIDI_OPTION_REMOVE_CONTROLS);
 
     for (option = 0; option < 2; option++) {
         ubidi_setReorderingOptions(pBiDi, option==0 ? UBIDI_OPTION_REMOVE_CONTROLS
                                                     : UBIDI_OPTION_INSERT_MARKS);
-        for (i = 0, nCases = LENGTHOF(testCases); i < nCases; i++) {
+        for (i = 0, nCases = UPRV_LENGTHOF(testCases); i < nCases; i++) {
             srcLen = strlen(testCases[i].textIn);
             pseudoToU16(srcLen, testCases[i].textIn, src);
             for(j = 0; j < 2; j++) {
                 log_verbose("Now doing test for option %d, case %d, level %d\n",
                             i, option, j);
                 level = paraLevels[j];
                 ubidi_setPara(pBiDi, src, srcLen, level, NULL, &rc);
                 assertSuccessful("ubidi_setPara", &rc);
                 *dest = 0;
                 destLen = ubidi_writeReordered(pBiDi, dest, MAXLEN, UBIDI_DO_MIRRORING, &rc);
@@ skipping 218 matching lines @@
             {"6, 4", "6, 4"}
         }
     };
     UChar src[MAXLEN];
     UBiDi *pBiDi = NULL;
     UChar *pSrc;
     UErrorCode rc = U_ZERO_ERROR;
     int32_t srcLen, processedLen, chunk, len, nPortions;
     int i, j, levelIndex;
     UBiDiLevel level;
-    int nTests = LENGTHOF(testData), nLevels = LENGTHOF(paraLevels);
+    int nTests = UPRV_LENGTHOF(testData), nLevels = UPRV_LENGTHOF(paraLevels);
     UBool mismatch, testOK = TRUE;
    char processedLenStr[MAXPORTIONS * 5];
 
     log_verbose("\nEntering TestStreaming\n\n");
 
     pBiDi = getBiDiObject();
 
     ubidi_orderParagraphsLTR(pBiDi, TRUE);
 
     for (levelIndex = 0; levelIndex < nLevels; levelIndex++) {
@@ skipping 69 matching lines @@
            AN,    AN,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 38-3F */
             L,    AL,    AL,    AL,    AL,    AL,    AL,     R, /* 40-47 */
             R,     R,     R,     R,     R,     R,     R,     R, /* 48-4F */
             R,     R,     R,     R,     R,     R,     R,     R, /* 50-57 */
             R,     R,     R,   LRE,   DEF,   RLE,   PDF,     S, /* 58-5F */
           NSM,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 60-67 */
           DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 68-6F */
           DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF,   DEF, /* 70-77 */
           DEF,   DEF,   DEF,   LRO,     B,   RLO,    BN,   DEF  /* 78-7F */
     };
-    static const int nEntries = LENGTHOF(customClasses);
+    static const int nEntries = UPRV_LENGTHOF(customClasses);
     const char *dummy = context;        /* just to avoid a compiler warning */
     dummy++;
 
     return c >= nEntries ? U_BIDI_CLASS_DEFAULT : customClasses[c];
 }
 
 U_CDECL_END
 
 static void verifyCallbackParams(UBiDiClassCallback* fn, const void* context,
                                  UBiDiClassCallback* expectedFn,
@@ skipping 267 matching lines @@
     /*17*/  {" x 7", ".-=abc-+*", " 8", "*+-.-=abc", UBIDI_RTL},
     /*18*/  {"x|", ".-=abc-+*", " 8", "*+-abc=-.", UBIDI_RTL},
     /*19*/  {"G|y", ".-=abc-+*", " 8", "*+-.-=abc", UBIDI_RTL},
     /*20*/  {"", ".-=", "", ".-=", UBIDI_DEFAULT_LTR},
     /*21*/  {"D", ".-=", "", "=-.", UBIDI_DEFAULT_LTR},
     /*22*/  {"G", ".-=", "", "=-.", UBIDI_DEFAULT_LTR},
     /*23*/  {"xG", ".-=", "", ".-=", UBIDI_DEFAULT_LTR},
     /*24*/  {"x|G", ".-=", "", "=-.", UBIDI_DEFAULT_LTR},
     /*25*/  {"x|G", ".-=|-+*", "", "=-.|-+*", UBIDI_DEFAULT_LTR},
 };
-#define CONTEXT_COUNT       LENGTHOF(contextData)
+#define CONTEXT_COUNT       UPRV_LENGTHOF(contextData)
 
 static void
 testContext(void) {
 
     UChar prologue[MAXLEN], epilogue[MAXLEN], src[MAXLEN], dest[MAXLEN];
     char destChars[MAXLEN];
     UBiDi *pBiDi = NULL;
     UErrorCode rc;
     int32_t proLength, epiLength, srcLen, destLen, tc;
     contextCase cc;
@@ skipping 71 matching lines @@
     log_verbose("\nExiting TestContext \n\n");
 }
 
 /* Ticket#11054 ubidi_setPara crash with heavily nested brackets */
 static void
 testBracketOverflow(void) {
     static const char* TEXT = "(((((((((((((((((((((((((((((((((((((((((a)(A)))))))))))))))))))))))))))))))))))))))))";
     UErrorCode status = U_ZERO_ERROR;
     UBiDi* bidi;
     UChar src[100];
-    UChar dest[100];
     int32_t len;
 
     bidi = ubidi_open();
     len = uprv_strlen(TEXT);
     pseudoToU16(len, TEXT, src);
     ubidi_setPara(bidi, src, len, UBIDI_DEFAULT_LTR , NULL, &status);
     if (U_FAILURE(status)) {
         log_err("setPara failed with heavily nested brackets - %s", u_errorName(status));
     }
 
     ubidi_close(bidi);
 }