ICU-64252.0.1.tar.gz

[apple/icu.git] / icuSources / test / cintltst / nucnvtst.c

diff --git a/icuSources/test/cintltst/nucnvtst.c b/icuSources/test/cintltst/nucnvtst.c
index f4a443cd9627b3d6c022da5ddb98fcf6c27ae6e1..ba8d131361372466f25a3886e5248d65153d6901 100644 (file)
--- a/icuSources/test/cintltst/nucnvtst.c
+++ b/icuSources/test/cintltst/nucnvtst.c
@@ -1,11 +1,13 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html

 /********************************************************************
  * COPYRIGHT:
 /********************************************************************
  * COPYRIGHT:

- * Copyright (c) 1997-2012, International Business Machines Corporation and
+ * Copyright (c) 1997-2016, International Business Machines Corporation and

  * others. All Rights Reserved.
  ********************************************************************/
 /*******************************************************************************
 *
  * others. All Rights Reserved.
  ********************************************************************/
 /*******************************************************************************
 *

-* File CCONVTST.C
+* File nucnvtst.c

 *
 * Modification History:
 *        Name                     Description
 *
 * Modification History:
 *        Name                     Description


@@ -26,8 +28,6 @@
 #include "cmemory.h"
 #include "nucnvtst.h"
 
 #include "cmemory.h"
 #include "nucnvtst.h"
 

-#define LENGTHOF(array) (sizeof(array)/sizeof((array)[0]))
-

 static void TestNextUChar(UConverter* cnv, const char* source, const char* limit, const int32_t results[], const char* message);
 static void TestNextUCharError(UConverter* cnv, const char* source, const char* limit, UErrorCode expected, const char* message);
 #if !UCONFIG_NO_COLLATION
 static void TestNextUChar(UConverter* cnv, const char* source, const char* limit, const int32_t results[], const char* message);
 static void TestNextUCharError(UConverter* cnv, const char* source, const char* limit, UErrorCode expected, const char* message);
 #if !UCONFIG_NO_COLLATION


@@ -405,7 +405,7 @@ static ETestConvertResult testConvertFromU( const UChar *source, int sourceLen,
     targ = junkout;
     offs = junokout;
 
     targ = junkout;
     offs = junokout;
 

-    realBufferSize = (sizeof(junkout)/sizeof(junkout[0]));
+    realBufferSize = UPRV_LENGTHOF(junkout);

     realBufferEnd = junkout + realBufferSize;
     realSourceEnd = source + sourceLen;
 
     realBufferEnd = junkout + realBufferSize;
     realSourceEnd = source + sourceLen;
 


@@ -563,7 +563,7 @@ static ETestConvertResult testConvertToU( const uint8_t *source, int sourcelen,
     targ = junkout;
     offs = junokout;
 
     targ = junkout;
     offs = junokout;
 

-    realBufferSize = (sizeof(junkout)/sizeof(junkout[0]));
+    realBufferSize = UPRV_LENGTHOF(junkout);

     realBufferEnd = junkout + realBufferSize;
     realSourceEnd = src + sourcelen;
 
     realBufferEnd = junkout + realBufferSize;
     realSourceEnd = src + sourcelen;
 


@@ -835,7 +835,7 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
 
 
     /*UTF-8*/
 
 
     /*UTF-8*/

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedUTF8, sizeof(expectedUTF8), "UTF8", toUTF8Offs,FALSE );
 
     log_verbose("Test surrogate behaviour for UTF8\n");
         expectedUTF8, sizeof(expectedUTF8), "UTF8", toUTF8Offs,FALSE );
 
     log_verbose("Test surrogate behaviour for UTF8\n");


@@ -846,7 +846,7 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
                            0xef, 0xbf, 0xbd
         };
         static const int32_t offsets[]={ 0, 0, 0, 1, 1, 1, 1, 3, 3, 3 };
                            0xef, 0xbf, 0xbd
         };
         static const int32_t offsets[]={ 0, 0, 0, 1, 1, 1, 1, 3, 3, 3 };

-        testConvertFromU(testinput, sizeof(testinput)/sizeof(testinput[0]),
+        testConvertFromU(testinput, UPRV_LENGTHOF(testinput),

                          expectedUTF8test2, sizeof(expectedUTF8test2), "UTF8", offsets,FALSE );
 
 
                          expectedUTF8test2, sizeof(expectedUTF8test2), "UTF8", offsets,FALSE );
 
 


@@ -854,47 +854,47 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
 
 #if !UCONFIG_NO_LEGACY_CONVERSION && defined(U_ENABLE_GENERIC_ISO_2022)
     /*ISO-2022*/
 
 #if !UCONFIG_NO_LEGACY_CONVERSION && defined(U_ENABLE_GENERIC_ISO_2022)
     /*ISO-2022*/

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedISO2022, sizeof(expectedISO2022), "ISO_2022", toISO2022Offs,FALSE );
 #endif
 
     /*UTF16 LE*/
         expectedISO2022, sizeof(expectedISO2022), "ISO_2022", toISO2022Offs,FALSE );
 #endif
 
     /*UTF16 LE*/

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedUTF16LE, sizeof(expectedUTF16LE), "utf-16le", toUTF16LEOffs,FALSE );
     /*UTF16 BE*/
         expectedUTF16LE, sizeof(expectedUTF16LE), "utf-16le", toUTF16LEOffs,FALSE );
     /*UTF16 BE*/

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedUTF16BE, sizeof(expectedUTF16BE), "utf-16be", toUTF16BEOffs,FALSE );
     /*UTF32 LE*/
         expectedUTF16BE, sizeof(expectedUTF16BE), "utf-16be", toUTF16BEOffs,FALSE );
     /*UTF32 LE*/

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedUTF32LE, sizeof(expectedUTF32LE), "utf-32le", toUTF32LEOffs,FALSE );
     /*UTF32 BE*/
         expectedUTF32LE, sizeof(expectedUTF32LE), "utf-32le", toUTF32LEOffs,FALSE );
     /*UTF32 BE*/

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedUTF32BE, sizeof(expectedUTF32BE), "utf-32be", toUTF32BEOffs,FALSE );
 
     /*LATIN_1*/
         expectedUTF32BE, sizeof(expectedUTF32BE), "utf-32be", toUTF32BEOffs,FALSE );
 
     /*LATIN_1*/

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedLATIN1, sizeof(expectedLATIN1), "LATIN_1", toLATIN1Offs,FALSE );
 
 #if !UCONFIG_NO_LEGACY_CONVERSION
     /*EBCDIC_STATEFUL*/
         expectedLATIN1, sizeof(expectedLATIN1), "LATIN_1", toLATIN1Offs,FALSE );
 
 #if !UCONFIG_NO_LEGACY_CONVERSION
     /*EBCDIC_STATEFUL*/

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedIBM930, sizeof(expectedIBM930), "ibm-930", toIBM930Offs,FALSE );
 
         expectedIBM930, sizeof(expectedIBM930), "ibm-930", toIBM930Offs,FALSE );
 

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedISO88593, sizeof(expectedISO88593), "iso-8859-3", toISO88593Offs,FALSE );
 
     /*MBCS*/
 
         expectedISO88593, sizeof(expectedISO88593), "iso-8859-3", toISO88593Offs,FALSE );
 
     /*MBCS*/
 

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedIBM943, sizeof(expectedIBM943), "ibm-943", toIBM943Offs,FALSE );
     /*DBCS*/
         expectedIBM943, sizeof(expectedIBM943), "ibm-943", toIBM943Offs,FALSE );
     /*DBCS*/

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedIBM9027, sizeof(expectedIBM9027), "@ibm9027", toIBM9027Offs,FALSE );
     /*SBCS*/
         expectedIBM9027, sizeof(expectedIBM9027), "@ibm9027", toIBM9027Offs,FALSE );
     /*SBCS*/

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedIBM920, sizeof(expectedIBM920), "ibm-920", toIBM920Offs,FALSE );
     /*SBCS*/
         expectedIBM920, sizeof(expectedIBM920), "ibm-920", toIBM920Offs,FALSE );
     /*SBCS*/

-    testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
+    testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),

         expectedISO88593, sizeof(expectedISO88593), "iso-8859-3", toISO88593Offs,FALSE );
 #endif
 
         expectedISO88593, sizeof(expectedISO88593), "iso-8859-3", toISO88593Offs,FALSE );
 #endif
 


@@ -903,51 +903,51 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
 
     /*UTF-8*/
     testConvertToU(expectedUTF8, sizeof(expectedUTF8),
 
     /*UTF-8*/
     testConvertToU(expectedUTF8, sizeof(expectedUTF8),

-        sampleText, sizeof(sampleText)/sizeof(sampleText[0]), "utf8", fmUTF8Offs,FALSE);
+        sampleText, UPRV_LENGTHOF(sampleText), "utf8", fmUTF8Offs,FALSE);

 #if !UCONFIG_NO_LEGACY_CONVERSION && defined(U_ENABLE_GENERIC_ISO_2022)
     /*ISO-2022*/
     testConvertToU(expectedISO2022, sizeof(expectedISO2022),
 #if !UCONFIG_NO_LEGACY_CONVERSION && defined(U_ENABLE_GENERIC_ISO_2022)
     /*ISO-2022*/
     testConvertToU(expectedISO2022, sizeof(expectedISO2022),

-        sampleText, sizeof(sampleText)/sizeof(sampleText[0]), "ISO_2022", fmISO2022Offs,FALSE);
+        sampleText, UPRV_LENGTHOF(sampleText), "ISO_2022", fmISO2022Offs,FALSE);

 #endif
 
     /*UTF16 LE*/
     testConvertToU(expectedUTF16LE, sizeof(expectedUTF16LE),
 #endif
 
     /*UTF16 LE*/
     testConvertToU(expectedUTF16LE, sizeof(expectedUTF16LE),

-        sampleText, sizeof(sampleText)/sizeof(sampleText[0]), "utf-16le", fmUTF16LEOffs,FALSE);
+        sampleText, UPRV_LENGTHOF(sampleText), "utf-16le", fmUTF16LEOffs,FALSE);

     /*UTF16 BE*/
     testConvertToU(expectedUTF16BE, sizeof(expectedUTF16BE),
     /*UTF16 BE*/
     testConvertToU(expectedUTF16BE, sizeof(expectedUTF16BE),

-        sampleText, sizeof(sampleText)/sizeof(sampleText[0]), "utf-16be", fmUTF16BEOffs,FALSE);
+        sampleText, UPRV_LENGTHOF(sampleText), "utf-16be", fmUTF16BEOffs,FALSE);

     /*UTF32 LE*/
     testConvertToU(expectedUTF32LE, sizeof(expectedUTF32LE),
     /*UTF32 LE*/
     testConvertToU(expectedUTF32LE, sizeof(expectedUTF32LE),

-        sampleText, sizeof(sampleText)/sizeof(sampleText[0]), "utf-32le", fmUTF32LEOffs,FALSE);
+        sampleText, UPRV_LENGTHOF(sampleText), "utf-32le", fmUTF32LEOffs,FALSE);

     /*UTF32 BE*/
     testConvertToU(expectedUTF32BE, sizeof(expectedUTF32BE),
     /*UTF32 BE*/
     testConvertToU(expectedUTF32BE, sizeof(expectedUTF32BE),

-        sampleText, sizeof(sampleText)/sizeof(sampleText[0]), "utf-32be", fmUTF32BEOffs,FALSE);
+        sampleText, UPRV_LENGTHOF(sampleText), "utf-32be", fmUTF32BEOffs,FALSE);

 
 #if !UCONFIG_NO_LEGACY_CONVERSION
     /*EBCDIC_STATEFUL*/
     testConvertToU(expectedIBM930, sizeof(expectedIBM930), sampleTextRoundTripUnmappable, 
 
 #if !UCONFIG_NO_LEGACY_CONVERSION
     /*EBCDIC_STATEFUL*/
     testConvertToU(expectedIBM930, sizeof(expectedIBM930), sampleTextRoundTripUnmappable, 

-            sizeof(sampleTextRoundTripUnmappable)/sizeof(sampleTextRoundTripUnmappable[0]), "ibm-930", fmIBM930Offs,FALSE);
+            UPRV_LENGTHOF(sampleTextRoundTripUnmappable), "ibm-930", fmIBM930Offs,FALSE);

     /*MBCS*/
     testConvertToU(expectedIBM943, sizeof(expectedIBM943),sampleTextRoundTripUnmappable, 
     /*MBCS*/
     testConvertToU(expectedIBM943, sizeof(expectedIBM943),sampleTextRoundTripUnmappable, 

-            sizeof(sampleTextRoundTripUnmappable)/sizeof(sampleTextRoundTripUnmappable[0]), "ibm-943", fmIBM943Offs,FALSE);
+            UPRV_LENGTHOF(sampleTextRoundTripUnmappable), "ibm-943", fmIBM943Offs,FALSE);

 #endif
 
     /* Try it again to make sure it still works */
     testConvertToU(expectedUTF16LE, sizeof(expectedUTF16LE),
 #endif
 
     /* Try it again to make sure it still works */
     testConvertToU(expectedUTF16LE, sizeof(expectedUTF16LE),

-        sampleText, sizeof(sampleText)/sizeof(sampleText[0]), "utf-16le", fmUTF16LEOffs,FALSE);
+        sampleText, UPRV_LENGTHOF(sampleText), "utf-16le", fmUTF16LEOffs,FALSE);

 
 #if !UCONFIG_NO_LEGACY_CONVERSION
     testConvertToU(expectedMaltese913, sizeof(expectedMaltese913),
 
 #if !UCONFIG_NO_LEGACY_CONVERSION
     testConvertToU(expectedMaltese913, sizeof(expectedMaltese913),

-        malteseUChars, sizeof(malteseUChars)/sizeof(malteseUChars[0]), "latin3", NULL,FALSE);
+        malteseUChars, UPRV_LENGTHOF(malteseUChars), "latin3", NULL,FALSE);

 
 

-    testConvertFromU(malteseUChars, sizeof(malteseUChars)/sizeof(malteseUChars[0]),
+    testConvertFromU(malteseUChars, UPRV_LENGTHOF(malteseUChars),

         expectedMaltese913, sizeof(expectedMaltese913), "iso-8859-3", NULL,FALSE );
 
     /*LMBCS*/
         expectedMaltese913, sizeof(expectedMaltese913), "iso-8859-3", NULL,FALSE );
 
     /*LMBCS*/

-    testConvertFromU(LMBCSUChars, sizeof(LMBCSUChars)/sizeof(LMBCSUChars[0]),
+    testConvertFromU(LMBCSUChars, UPRV_LENGTHOF(LMBCSUChars),

         expectedLMBCS, sizeof(expectedLMBCS), "LMBCS-1", toLMBCSOffs,FALSE );
     testConvertToU(expectedLMBCS, sizeof(expectedLMBCS),
         expectedLMBCS, sizeof(expectedLMBCS), "LMBCS-1", toLMBCSOffs,FALSE );
     testConvertToU(expectedLMBCS, sizeof(expectedLMBCS),

-        LMBCSUChars, sizeof(LMBCSUChars)/sizeof(LMBCSUChars[0]), "LMBCS-1", fmLMBCSOffs,FALSE);
+        LMBCSUChars, UPRV_LENGTHOF(LMBCSUChars), "LMBCS-1", fmLMBCSOffs,FALSE);

 #endif
 
     /* UTF-7 examples are mostly from http://www.imc.org/rfc2152 */
 #endif
 
     /* UTF-7 examples are mostly from http://www.imc.org/rfc2152 */


@@ -1016,13 +1016,13 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
             16, 16, 16, 17, 17, 17, 18, 18, 18, 18
         };
 
             16, 16, 16, 17, 17, 17, 18, 18, 18, 18
         };
 

-        testConvertFromU(unicode, sizeof(unicode)/U_SIZEOF_UCHAR, utf7, sizeof(utf7), "UTF-7", fromUnicodeOffsets,FALSE);
+        testConvertFromU(unicode, UPRV_LENGTHOF(unicode), utf7, sizeof(utf7), "UTF-7", fromUnicodeOffsets,FALSE);

 
 

-        testConvertToU(utf7, sizeof(utf7), unicode, sizeof(unicode)/U_SIZEOF_UCHAR, "UTF-7", toUnicodeOffsets,FALSE);
+        testConvertToU(utf7, sizeof(utf7), unicode, UPRV_LENGTHOF(unicode), "UTF-7", toUnicodeOffsets,FALSE);

 
 

-        testConvertFromU(unicode, sizeof(unicode)/U_SIZEOF_UCHAR, utf7Restricted, sizeof(utf7Restricted), "UTF-7,version=1", fromUnicodeOffsetsR,FALSE);
+        testConvertFromU(unicode, UPRV_LENGTHOF(unicode), utf7Restricted, sizeof(utf7Restricted), "UTF-7,version=1", fromUnicodeOffsetsR,FALSE);

 
 

-        testConvertToU(utf7Restricted, sizeof(utf7Restricted), unicode, sizeof(unicode)/U_SIZEOF_UCHAR, "UTF-7,version=1", toUnicodeOffsetsR,FALSE);
+        testConvertToU(utf7Restricted, sizeof(utf7Restricted), unicode, UPRV_LENGTHOF(unicode), "UTF-7,version=1", toUnicodeOffsetsR,FALSE);

     }
 
     /*
     }
 
     /*


@@ -1096,9 +1096,9 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
             35, 36, 36, 36, 37, 37, 37, 37, 37
         };
 
             35, 36, 36, 36, 37, 37, 37, 37, 37
         };
 

-        testConvertFromU(unicode, sizeof(unicode)/U_SIZEOF_UCHAR, imap, sizeof(imap), "IMAP-mailbox-name", fromUnicodeOffsets,FALSE);
+        testConvertFromU(unicode, UPRV_LENGTHOF(unicode), imap, sizeof(imap), "IMAP-mailbox-name", fromUnicodeOffsets,FALSE);

 
 

-        testConvertToU(imap, sizeof(imap), unicode, sizeof(unicode)/U_SIZEOF_UCHAR, "IMAP-mailbox-name", toUnicodeOffsets,FALSE);
+        testConvertToU(imap, sizeof(imap), unicode, UPRV_LENGTHOF(unicode), "IMAP-mailbox-name", toUnicodeOffsets,FALSE);

     }
 
     /* Test UTF-8 bad data handling*/
     }
 
     /* Test UTF-8 bad data handling*/


@@ -1113,29 +1113,39 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
             0xf4, 0x8f, 0xbf, 0xbf,         /* 10FFFF */
             0xdf, 0xbf,                     /* 7ff */
             0xbf,                           /* truncated tail */
             0xf4, 0x8f, 0xbf, 0xbf,         /* 10FFFF */
             0xdf, 0xbf,                     /* 7ff */
             0xbf,                           /* truncated tail */

-            0xf4, 0x90, 0x80, 0x80,         /* 11FFFF */
+            0xf4, 0x90, 0x80, 0x80,         /* 110000 */

             0x02
         };
 
         static const uint16_t utf8Expected[]={
             0x0061,
             0x02
         };
 
         static const uint16_t utf8Expected[]={
             0x0061,

-            0xfffd,
+            0xfffd, 0xfffd, 0xfffd, 0xfffd,

             0x0000,
             0x0062,
             0x0000,
             0x0062,

-            0xfffd,
-            0xfffd,
+            0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
+            0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,

             0xdbff, 0xdfff,
             0x07ff,
             0xfffd,
             0xdbff, 0xdfff,
             0x07ff,
             0xfffd,

-            0xfffd,
+            0xfffd, 0xfffd, 0xfffd, 0xfffd,

             0x0002
         };
 
         static const int32_t utf8Offsets[]={
             0x0002
         };
 
         static const int32_t utf8Offsets[]={

-            0, 1, 5, 6, 7, 12, 17, 17, 21, 23, 24, 28
+            0,
+            1, 2, 3, 4,
+            5,
+            6,
+            7, 8, 9, 10, 11,
+            12, 13, 14, 15, 16,
+            17, 17,
+            21,
+            23,
+            24, 25, 26, 27,
+            28

         };
         testConvertToU(utf8, sizeof(utf8),
         };
         testConvertToU(utf8, sizeof(utf8),

-                       utf8Expected, sizeof(utf8Expected)/sizeof(utf8Expected[0]), "utf-8", utf8Offsets ,FALSE);
+                       utf8Expected, UPRV_LENGTHOF(utf8Expected), "utf-8", utf8Offsets ,FALSE);

 
     }
 
 
     }
 


@@ -1187,8 +1197,8 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
         };
 
         testConvertToU(utf32, sizeof(utf32),
         };
 
         testConvertToU(utf32, sizeof(utf32),

-                       utf32Expected, sizeof(utf32Expected)/sizeof(utf32Expected[0]), "utf-32be", utf32Offsets ,FALSE);
-        testConvertFromU(utf32Expected, sizeof(utf32Expected)/sizeof(utf32Expected[0]),
+                       utf32Expected, UPRV_LENGTHOF(utf32Expected), "utf-32be", utf32Offsets ,FALSE);
+        testConvertFromU(utf32Expected, UPRV_LENGTHOF(utf32Expected),

             utf32ExpectedBack, sizeof(utf32ExpectedBack), "utf-32be", utf32OffsetsBack, FALSE);
     }
 
             utf32ExpectedBack, sizeof(utf32ExpectedBack), "utf-32be", utf32OffsetsBack, FALSE);
     }
 


@@ -1240,8 +1250,8 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
             8,8,8,8
         };
         testConvertToU(utf32, sizeof(utf32),
             8,8,8,8
         };
         testConvertToU(utf32, sizeof(utf32),

-            utf32Expected, sizeof(utf32Expected)/sizeof(utf32Expected[0]), "utf-32le", utf32Offsets,FALSE );
-        testConvertFromU(utf32Expected, sizeof(utf32Expected)/sizeof(utf32Expected[0]),
+            utf32Expected, UPRV_LENGTHOF(utf32Expected), "utf-32le", utf32Offsets,FALSE );
+        testConvertFromU(utf32Expected, UPRV_LENGTHOF(utf32Expected),

             utf32ExpectedBack, sizeof(utf32ExpectedBack), "utf-32le", utf32OffsetsBack, FALSE);
     }
 }
             utf32ExpectedBack, sizeof(utf32ExpectedBack), "utf-32le", utf32OffsetsBack, FALSE);
     }
 }


@@ -1278,7 +1288,7 @@ static void TestCoverageMBCS(){
         int32_t  totest1Offs[]        = { 0, 1, 2, 3, 5, };
 
         /*from Unicode*/
         int32_t  totest1Offs[]        = { 0, 1, 2, 3, 5, };
 
         /*from Unicode*/

-        testConvertFromU(unicodeInput, sizeof(unicodeInput)/sizeof(unicodeInput[0]),
+        testConvertFromU(unicodeInput, UPRV_LENGTHOF(unicodeInput),

             expectedtest1, sizeof(expectedtest1), "@test1", totest1Offs,FALSE );
     }
 
             expectedtest1, sizeof(expectedtest1), "@test1", totest1Offs,FALSE );
     }
 


@@ -1296,12 +1306,12 @@ static void TestCoverageMBCS(){
         int32_t fromtest3Offs[]       = { 0, 1, 2, 3, 6, 6, 7, 7, 10 };
 
         /*from Unicode*/
         int32_t fromtest3Offs[]       = { 0, 1, 2, 3, 6, 6, 7, 7, 10 };
 
         /*from Unicode*/

-        testConvertFromU(unicodeInput, sizeof(unicodeInput)/sizeof(unicodeInput[0]),
+        testConvertFromU(unicodeInput, UPRV_LENGTHOF(unicodeInput),

             expectedtest3, sizeof(expectedtest3), "@test3", totest3Offs,FALSE );
 
         /*to Unicode*/
         testConvertToU(test3input, sizeof(test3input),
             expectedtest3, sizeof(expectedtest3), "@test3", totest3Offs,FALSE );
 
         /*to Unicode*/
         testConvertToU(test3input, sizeof(test3input),

-            expectedUnicode, sizeof(expectedUnicode)/sizeof(expectedUnicode[0]), "@test3", fromtest3Offs ,FALSE);
+            expectedUnicode, UPRV_LENGTHOF(expectedUnicode), "@test3", fromtest3Offs ,FALSE);

 
     }
 
 
     }
 


@@ -1319,12 +1329,12 @@ static void TestCoverageMBCS(){
         static const int32_t fromtest4Offs[] = { 0, 1, 2, 3, 7, 7, 8, 8, 12,};
 
         /*from Unicode*/
         static const int32_t fromtest4Offs[] = { 0, 1, 2, 3, 7, 7, 8, 8, 12,};
 
         /*from Unicode*/

-        testConvertFromU(unicodeInput, sizeof(unicodeInput)/sizeof(unicodeInput[0]),
+        testConvertFromU(unicodeInput, UPRV_LENGTHOF(unicodeInput),

             expectedtest4, sizeof(expectedtest4), "@test4", totest4Offs,FALSE );
 
         /*to Unicode*/
         testConvertToU(test4input, sizeof(test4input),
             expectedtest4, sizeof(expectedtest4), "@test4", totest4Offs,FALSE );
 
         /*to Unicode*/
         testConvertToU(test4input, sizeof(test4input),

-            expectedUnicode, sizeof(expectedUnicode)/sizeof(expectedUnicode[0]), "@test4", fromtest4Offs,FALSE );
+            expectedUnicode, UPRV_LENGTHOF(expectedUnicode), "@test4", fromtest4Offs,FALSE );

 
     }
 #if 0
 
     }
 #if 0


@@ -1548,7 +1558,7 @@ static void TestAmbiguous()
         return;
     }
     /* convert target from SJIS to Unicode */
         return;
     }
     /* convert target from SJIS to Unicode */

-    sjisLength = ucnv_toUChars(sjis_cnv, sjisResult, sizeof(sjisResult)/U_SIZEOF_UCHAR, target, (int32_t)strlen(target), &status);
+    sjisLength = ucnv_toUChars(sjis_cnv, sjisResult, UPRV_LENGTHOF(sjisResult), target, (int32_t)strlen(target), &status);

     if (U_FAILURE(status))
     {
         log_err("Failed to convert the SJIS string.\n");
     if (U_FAILURE(status))
     {
         log_err("Failed to convert the SJIS string.\n");


@@ -1557,7 +1567,7 @@ static void TestAmbiguous()
         return;
     }
     /* convert target from Latin-1 to Unicode */
         return;
     }
     /* convert target from Latin-1 to Unicode */

-    /*asciiLength =*/ ucnv_toUChars(ascii_cnv, asciiResult, sizeof(asciiResult)/U_SIZEOF_UCHAR, target, (int32_t)strlen(target), &status);
+    /*asciiLength =*/ ucnv_toUChars(ascii_cnv, asciiResult, UPRV_LENGTHOF(asciiResult), target, (int32_t)strlen(target), &status);

     if (U_FAILURE(status))
     {
         log_err("Failed to convert the Latin-1 string.\n");
     if (U_FAILURE(status))
     {
         log_err("Failed to convert the Latin-1 string.\n");


@@ -1665,7 +1675,7 @@ TestSignatureDetection(){
         int32_t signatureLength = -1;
         const char* source = NULL;
         const char* enc = NULL;
         int32_t signatureLength = -1;
         const char* source = NULL;
         const char* enc = NULL;

-        for( ; i<sizeof(data)/sizeof(char*); i++){
+        for( ; i<UPRV_LENGTHOF(data); i++){

             err = U_ZERO_ERROR;
             source = data[i];
             enc = ucnv_detectUnicodeSignature(source, -1 , &signatureLength, &err);
             err = U_ZERO_ERROR;
             source = data[i];
             enc = ucnv_detectUnicodeSignature(source, -1 , &signatureLength, &err);


@@ -1778,7 +1788,7 @@ TestSignatureDetection(){
         int32_t sourceLength=-1;
         const char* source = NULL;
         const char* enc = NULL;
         int32_t sourceLength=-1;
         const char* source = NULL;
         const char* enc = NULL;

-        for( ; i<sizeof(data)/sizeof(char*); i++){
+        for( ; i<UPRV_LENGTHOF(data); i++){

             err = U_ZERO_ERROR;
             source = data[i];
             sourceLength = len[i];
             err = U_ZERO_ERROR;
             source = data[i];
             sourceLength = len[i];


@@ -1830,7 +1840,7 @@ static void TestUTF7() {
     UErrorCode errorCode=U_ZERO_ERROR;
     UConverter *cnv=ucnv_open("UTF-7", &errorCode);
     if(U_FAILURE(errorCode)) {
     UErrorCode errorCode=U_ZERO_ERROR;
     UConverter *cnv=ucnv_open("UTF-7", &errorCode);
     if(U_FAILURE(errorCode)) {

-        log_err("Unable to open a UTF-7 converter: %s\n", u_errorName(errorCode)); /* sholdn't be a data err */
+        log_data_err("Unable to open a UTF-7 converter: %s\n", u_errorName(errorCode));

         return;
     }
     TestNextUChar(cnv, source, limit, results, "UTF-7");
         return;
     }
     TestNextUChar(cnv, source, limit, results, "UTF-7");


@@ -1873,7 +1883,7 @@ static void TestIMAP() {
     UErrorCode errorCode=U_ZERO_ERROR;
     UConverter *cnv=ucnv_open("IMAP-mailbox-name", &errorCode);
     if(U_FAILURE(errorCode)) {
     UErrorCode errorCode=U_ZERO_ERROR;
     UConverter *cnv=ucnv_open("IMAP-mailbox-name", &errorCode);
     if(U_FAILURE(errorCode)) {

-        log_err("Unable to open a IMAP-mailbox-name converter: %s\n", u_errorName(errorCode)); /* sholdn't be a data err */
+        log_data_err("Unable to open a IMAP-mailbox-name converter: %s\n", u_errorName(errorCode));

         return;
     }
     TestNextUChar(cnv, source, limit, results, "IMAP-mailbox-name");
         return;
     }
     TestNextUChar(cnv, source, limit, results, "IMAP-mailbox-name");


@@ -2006,7 +2016,7 @@ static void TestCESU8() {
     UErrorCode errorCode=U_ZERO_ERROR;
     UConverter *cnv=ucnv_open("CESU-8", &errorCode);
     if(U_FAILURE(errorCode)) {
     UErrorCode errorCode=U_ZERO_ERROR;
     UConverter *cnv=ucnv_open("CESU-8", &errorCode);
     if(U_FAILURE(errorCode)) {

-        log_err("Unable to open a CESU-8 converter: %s\n", u_errorName(errorCode));
+        log_data_err("Unable to open a CESU-8 converter: %s\n", u_errorName(errorCode));

         return;
     }
     TestNextUChar(cnv, source, limit, results, "CESU-8");
         return;
     }
     TestNextUChar(cnv, source, limit, results, "CESU-8");


@@ -2226,7 +2236,7 @@ static void TestUTF32() {
     UErrorCode errorCode=U_ZERO_ERROR;
     UConverter *cnv=ucnv_open("UTF-32", &errorCode);
     if(U_FAILURE(errorCode)) {
     UErrorCode errorCode=U_ZERO_ERROR;
     UConverter *cnv=ucnv_open("UTF-32", &errorCode);
     if(U_FAILURE(errorCode)) {

-        log_err("Unable to open a UTF-32 converter: %s\n", u_errorName(errorCode));
+        log_data_err("Unable to open a UTF-32 converter: %s\n", u_errorName(errorCode));

         return;
     }
 
         return;
     }
 


@@ -2302,7 +2312,7 @@ TestUTF32BE() {
     UErrorCode errorCode=U_ZERO_ERROR;
     UConverter *cnv=ucnv_open("UTF-32BE", &errorCode);
     if(U_FAILURE(errorCode)) {
     UErrorCode errorCode=U_ZERO_ERROR;
     UConverter *cnv=ucnv_open("UTF-32BE", &errorCode);
     if(U_FAILURE(errorCode)) {

-        log_err("Unable to open a UTF-32BE converter: %s\n", u_errorName(errorCode));
+        log_data_err("Unable to open a UTF-32BE converter: %s\n", u_errorName(errorCode));

         return;
     }
     TestNextUChar(cnv, source, limit, results, "UTF-32BE");
         return;
     }
     TestNextUChar(cnv, source, limit, results, "UTF-32BE");


@@ -2373,7 +2383,7 @@ TestUTF32LE() {
     UErrorCode errorCode=U_ZERO_ERROR;
     UConverter *cnv=ucnv_open("UTF-32LE", &errorCode);
     if(U_FAILURE(errorCode)) {
     UErrorCode errorCode=U_ZERO_ERROR;
     UConverter *cnv=ucnv_open("UTF-32LE", &errorCode);
     if(U_FAILURE(errorCode)) {

-        log_err("Unable to open a UTF-32LE converter: %s\n", u_errorName(errorCode));
+        log_data_err("Unable to open a UTF-32LE converter: %s\n", u_errorName(errorCode));

         return;
     }
     TestNextUChar(cnv, source, limit, results, "UTF-32LE");
         return;
     }
     TestNextUChar(cnv, source, limit, results, "UTF-32LE");


@@ -3101,7 +3111,7 @@ TestHZ() {
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
     uSource = (const UChar*)in;
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
     uSource = (const UChar*)in;

-    uSourceLimit=(const UChar*)in + (sizeof(in)/sizeof(in[0]));
+    uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);

     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;
     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;


@@ -3130,9 +3140,9 @@ TestHZ() {
         test++;
     }
     TestGetNextUChar2022(cnv, cBuf, cTarget, in, "HZ encoding");
         test++;
     }
     TestGetNextUChar2022(cnv, cBuf, cTarget, in, "HZ encoding");

-    TestSmallTargetBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
-    TestSmallSourceBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
-    TestToAndFromUChars(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
+    TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
+    TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
+    TestToAndFromUChars(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);

     TestJitterbug930("csISO2022JP");
     ucnv_close(cnv);
     free(offsets);
     TestJitterbug930("csISO2022JP");
     ucnv_close(cnv);
     free(offsets);


@@ -3278,7 +3288,7 @@ TestISCII(){
         0xEF, 0x30,
 
     };
         0xEF, 0x30,
 
     };

-    testConvertToU(byteArr,(sizeof(byteArr)),in,(sizeof(in)/U_SIZEOF_UCHAR),"x-iscii-de",NULL,TRUE);
+    testConvertToU(byteArr,(sizeof(byteArr)),in,UPRV_LENGTHOF(in),"x-iscii-de",NULL,TRUE);

     TestConv(in,(sizeof(in)/2),"ISCII,version=0","hindi", (char *)byteArr,sizeof(byteArr));    
 
 }
     TestConv(in,(sizeof(in)/2),"ISCII,version=0","hindi", (char *)byteArr,sizeof(byteArr));    
 
 }


@@ -3320,7 +3330,7 @@ TestISO_2022_JP() {
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
     uSource = (const UChar*)in;
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
     uSource = (const UChar*)in;

-    uSourceLimit=(const UChar*)in + (sizeof(in)/sizeof(in[0]));
+    uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);

     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;
     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;


@@ -3350,10 +3360,10 @@ TestISO_2022_JP() {
         test++;
     }
 
         test++;
     }
 

-    TestSmallTargetBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
-    TestSmallSourceBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
+    TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
+    TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);

     TestGetNextUChar2022(cnv, cBuf, cTarget, in, "ISO-2022-JP encoding");
     TestGetNextUChar2022(cnv, cBuf, cTarget, in, "ISO-2022-JP encoding");

-    TestToAndFromUChars(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
+    TestToAndFromUChars(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);

     TestJitterbug930("csISO2022JP");
     ucnv_close(cnv);
     free(uBuf);
     TestJitterbug930("csISO2022JP");
     ucnv_close(cnv);
     free(uBuf);


@@ -3750,7 +3760,7 @@ TestSCSU() {
           "\\uf95b\\u2458\\u2468\\u0e20\\uf51b\\ue36e\\ubfc1\\u0080\\u02dd\\uf1b5\\u0cf3\\u6059\\u7489",
     };
     int i=0;
           "\\uf95b\\u2458\\u2468\\u0e20\\uf51b\\ue36e\\ubfc1\\u0080\\u02dd\\uf1b5\\u0cf3\\u6059\\u7489",
     };
     int i=0;

-    for(;i<sizeof(fTestCases)/sizeof(*fTestCases);i++){
+    for(;i<UPRV_LENGTHOF(fTestCases);i++){

         const char* cSrc = fTestCases[i];
         UErrorCode status = U_ZERO_ERROR;
         int32_t cSrcLen,srcLen;
         const char* cSrc = fTestCases[i];
         UErrorCode status = U_ZERO_ERROR;
         int32_t cSrcLen,srcLen;


@@ -3862,7 +3872,7 @@ TestISO_2022_JP_1() {
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
     uSource = (const UChar*)in;
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
     uSource = (const UChar*)in;

-    uSourceLimit=(const UChar*)in + (sizeof(in)/sizeof(in[0]));
+    uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);

     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;
     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;


@@ -3897,8 +3907,8 @@ TestISO_2022_JP_1() {
         static const uint8_t source2[]={0x0e,0x24,0x053};
         TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_ZERO_ERROR, "an invalid character [ISO-2022-JP-1]");
     }
         static const uint8_t source2[]={0x0e,0x24,0x053};
         TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_ZERO_ERROR, "an invalid character [ISO-2022-JP-1]");
     }

-    TestSmallTargetBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
-    TestSmallSourceBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
+    TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
+    TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);

     ucnv_close(cnv);
     free(uBuf);
     free(cBuf);
     ucnv_close(cnv);
     free(uBuf);
     free(cBuf);


@@ -3952,7 +3962,7 @@ TestISO_2022_JP_2() {
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
     uSource = (const UChar*)in;
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
     uSource = (const UChar*)in;

-    uSourceLimit=(const UChar*)in + (sizeof(in)/sizeof(in[0]));
+    uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);

     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;
     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;


@@ -3980,9 +3990,9 @@ TestISO_2022_JP_2() {
         uSource++;
         test++;
     }
         uSource++;
         test++;
     }

-    TestSmallTargetBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
-    TestSmallSourceBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
-    TestToAndFromUChars(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
+    TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
+    TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
+    TestToAndFromUChars(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);

     /*Test for the condition where there is an invalid character*/
     ucnv_reset(cnv);
     {
     /*Test for the condition where there is an invalid character*/
     ucnv_reset(cnv);
     {


@@ -4029,7 +4039,7 @@ TestISO_2022_KR() {
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
     uSource = (const UChar*)in;
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
     uSource = (const UChar*)in;

-    uSourceLimit=(const UChar*)in + (sizeof(in)/sizeof(in[0]));
+    uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);

     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;
     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;


@@ -4057,9 +4067,9 @@ TestISO_2022_KR() {
         test++;
     }
     TestGetNextUChar2022(cnv, cBuf, cTarget, in, "ISO-2022-KR encoding");
         test++;
     }
     TestGetNextUChar2022(cnv, cBuf, cTarget, in, "ISO-2022-KR encoding");

-    TestSmallTargetBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
-    TestSmallSourceBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
-    TestToAndFromUChars(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
+    TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
+    TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
+    TestToAndFromUChars(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);

     TestJitterbug930("csISO2022KR");
     /*Test for the condition where there is an invalid character*/
     ucnv_reset(cnv);
     TestJitterbug930("csISO2022KR");
     /*Test for the condition where there is an invalid character*/
     ucnv_reset(cnv);


@@ -4108,7 +4118,7 @@ TestISO_2022_KR_1() {
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
     uSource = (const UChar*)in;
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
     uSource = (const UChar*)in;

-    uSourceLimit=(const UChar*)in + (sizeof(in)/sizeof(in[0]));
+    uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);

     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;
     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;


@@ -4137,10 +4147,10 @@ TestISO_2022_KR_1() {
     }
     ucnv_reset(cnv);
     TestGetNextUChar2022(cnv, cBuf, cTarget, in, "ISO-2022-KR encoding");
     }
     ucnv_reset(cnv);
     TestGetNextUChar2022(cnv, cBuf, cTarget, in, "ISO-2022-KR encoding");

-    TestSmallTargetBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
-    TestSmallSourceBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
+    TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
+    TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);

     ucnv_reset(cnv);
     ucnv_reset(cnv);

-    TestToAndFromUChars(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
+    TestToAndFromUChars(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);

         /*Test for the condition where there is an invalid character*/
     ucnv_reset(cnv);
     {
         /*Test for the condition where there is an invalid character*/
     ucnv_reset(cnv);
     {


@@ -4257,11 +4267,11 @@ TestJIS(){
         };
 
         testConvertToU(sampleTextJIS,sizeof(sampleTextJIS),expectedISO2022JIS,
         };
 
         testConvertToU(sampleTextJIS,sizeof(sampleTextJIS),expectedISO2022JIS,

-            sizeof(expectedISO2022JIS)/sizeof(expectedISO2022JIS[0]),"JIS", toISO2022JISOffs,TRUE);
+            UPRV_LENGTHOF(expectedISO2022JIS),"JIS", toISO2022JISOffs,TRUE);

         testConvertToU(sampleTextJIS7,sizeof(sampleTextJIS7),expectedISO2022JIS7,
         testConvertToU(sampleTextJIS7,sizeof(sampleTextJIS7),expectedISO2022JIS7,

-            sizeof(expectedISO2022JIS7)/sizeof(expectedISO2022JIS7[0]),"JIS7", toISO2022JIS7Offs,TRUE);
+            UPRV_LENGTHOF(expectedISO2022JIS7),"JIS7", toISO2022JIS7Offs,TRUE);

         testConvertToU(sampleTextJIS8,sizeof(sampleTextJIS8),expectedISO2022JIS8,
         testConvertToU(sampleTextJIS8,sizeof(sampleTextJIS8),expectedISO2022JIS8,

-            sizeof(expectedISO2022JIS8)/sizeof(expectedISO2022JIS8[0]),"JIS8", toISO2022JIS8Offs,TRUE);
+            UPRV_LENGTHOF(expectedISO2022JIS8),"JIS8", toISO2022JIS8Offs,TRUE);

     }
 
 }
     }
 
 }


@@ -4414,7 +4424,7 @@ TestISO_2022_CN_EXT() {
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 10);
     uSource = (const UChar*)in;
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 10);
     uSource = (const UChar*)in;

-    uSourceLimit=(const UChar*)in + (sizeof(in)/sizeof(in[0]));
+    uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);

     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;
     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;


@@ -4444,8 +4454,8 @@ TestISO_2022_CN_EXT() {
         uSource++;
         test++;
     }
         uSource++;
         test++;
     }

-    TestSmallTargetBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
-    TestSmallSourceBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
+    TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
+    TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);

     /*Test for the condition where there is an invalid character*/
     ucnv_reset(cnv);
     {
     /*Test for the condition where there is an invalid character*/
     ucnv_reset(cnv);
     {


@@ -4513,7 +4523,7 @@ TestISO_2022_CN() {
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 10);
     uSource = (const UChar*)in;
     uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar)*5);
     cBuf =(char*)malloc(uBufSize * sizeof(char) * 10);
     uSource = (const UChar*)in;

-    uSourceLimit=(const UChar*)in + (sizeof(in)/sizeof(in[0]));
+    uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);

     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;
     cTarget = cBuf;
     cTargetLimit = cBuf +uBufSize*5;
     uTarget = uBuf;


@@ -4544,9 +4554,9 @@ TestISO_2022_CN() {
         test++;
     }
     TestGetNextUChar2022(cnv, cBuf, cTarget, in, "ISO-2022-CN encoding");
         test++;
     }
     TestGetNextUChar2022(cnv, cBuf, cTarget, in, "ISO-2022-CN encoding");

-    TestSmallTargetBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
-    TestSmallSourceBuffer(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
-    TestToAndFromUChars(in,(const UChar*)in + (sizeof(in)/sizeof(in[0])),cnv);
+    TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
+    TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
+    TestToAndFromUChars(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);

     TestJitterbug930("csISO2022CN");
     /*Test for the condition where there is an invalid character*/
     ucnv_reset(cnv);
     TestJitterbug930("csISO2022CN");
     /*Test for the condition where there is an invalid character*/
     ucnv_reset(cnv);


@@ -4910,14 +4920,14 @@ TestLMBCS() {
 
        UChar Out [sizeof(pszUnicode) + 1];
        UChar * pOut = Out;
 
        UChar Out [sizeof(pszUnicode) + 1];
        UChar * pOut = Out;

-       UChar * OutLimit = Out + sizeof(pszUnicode)/sizeof(UChar);
+       UChar * OutLimit = Out + UPRV_LENGTHOF(pszUnicode);

 
        int32_t off [sizeof(offsets)];
 
       /* last 'offset' in expected results is just the final size.
          (Makes other tests easier). Compensate here: */
 
 
        int32_t off [sizeof(offsets)];
 
       /* last 'offset' in expected results is just the final size.
          (Makes other tests easier). Compensate here: */
 

-       off[(sizeof(offsets)/sizeof(offsets[0]))-1] = sizeof(pszLMBCS);
+       off[UPRV_LENGTHOF(offsets)-1] = sizeof(pszLMBCS);

 
 
 
 
 
 


@@ -5000,8 +5010,8 @@ TestLMBCS() {
 
       /* 0192 (hook) converts to both group 3 & group 1. input locale should differentiate */
       ucnv_fromUnicode (cnv16he,
 
       /* 0192 (hook) converts to both group 3 & group 1. input locale should differentiate */
       ucnv_fromUnicode (cnv16he,

-                        &pLMBCSIn, (pLMBCSIn + sizeof(lmbcsString)/sizeof(lmbcsString[0])),
-                        &pUniOut, pUniOut + sizeof(uniString)/sizeof(uniString[0]),
+                        &pLMBCSIn, (pLMBCSIn + UPRV_LENGTHOF(lmbcsString)),
+                        &pUniOut, pUniOut + UPRV_LENGTHOF(uniString),

                         NULL, 1, &errorCode);
 
       if (lmbcsString[0] != 0x3 || lmbcsString[1] != 0x83)
                         NULL, 1, &errorCode);
 
       if (lmbcsString[0] != 0x3 || lmbcsString[1] != 0x83)


@@ -5012,8 +5022,8 @@ TestLMBCS() {
       pLMBCSIn= (char *)lmbcsString;
       pUniOut = uniString;
       ucnv_fromUnicode (cnv01us,
       pLMBCSIn= (char *)lmbcsString;
       pUniOut = uniString;
       ucnv_fromUnicode (cnv01us,

-                        &pLMBCSIn, (const char *)(lmbcsString + sizeof(lmbcsString)/sizeof(lmbcsString[0])),
-                        &pUniOut, pUniOut + sizeof(uniString)/sizeof(uniString[0]),
+                        &pLMBCSIn, (const char *)(lmbcsString + UPRV_LENGTHOF(lmbcsString)),
+                        &pUniOut, pUniOut + UPRV_LENGTHOF(uniString),

                         NULL, 1, &errorCode);
 
       if (lmbcsString[0] != 0x9F)
                         NULL, 1, &errorCode);
 
       if (lmbcsString[0] != 0x9F)


@@ -5080,7 +5090,7 @@ TestLMBCS() {
 
        UChar Out [sizeof(pszUnicode) + 1];
        UChar * pOut = Out;
 
        UChar Out [sizeof(pszUnicode) + 1];
        UChar * pOut = Out;

-       UChar * OutLimit = Out + sizeof(pszUnicode)/sizeof(UChar);
+       UChar * OutLimit = Out + UPRV_LENGTHOF(pszUnicode);

 
 
        cnv = ucnv_open(NAME_LMBCS_1, &errorCode);
 
 
        cnv = ucnv_open(NAME_LMBCS_1, &errorCode);


@@ -5189,7 +5199,7 @@ TestLMBCS() {
          /* running out of target room : U_BUFFER_OVERFLOW_ERROR */
 
          pUIn = pszUnicode;
          /* running out of target room : U_BUFFER_OVERFLOW_ERROR */
 
          pUIn = pszUnicode;

-         ucnv_fromUnicode(cnv, &pLOut,pLOut+offsets[4],&pUIn,pUIn+sizeof(pszUnicode)/sizeof(UChar),off,FALSE, &errorCode);
+         ucnv_fromUnicode(cnv, &pLOut,pLOut+offsets[4],&pUIn,pUIn+UPRV_LENGTHOF(pszUnicode),off,FALSE, &errorCode);

          if (errorCode != U_BUFFER_OVERFLOW_ERROR || pLOut != LOut + offsets[4] || pUIn != pszUnicode+4 )
          {
             log_err("Unexpected results on out of target room to ucnv_fromUnicode\n");
          if (errorCode != U_BUFFER_OVERFLOW_ERROR || pLOut != LOut + offsets[4] || pUIn != pszUnicode+4 )
          {
             log_err("Unexpected results on out of target room to ucnv_fromUnicode\n");


@@ -5217,7 +5227,7 @@ TestLMBCS() {
          pUOut = UOut;
 
          ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_STOP, NULL, NULL, NULL, &errorCode);
          pUOut = UOut;
 
          ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_STOP, NULL, NULL, NULL, &errorCode);

-         ucnv_toUnicode(cnv, &pUOut,pUOut+sizeof(UOut)/sizeof(UChar),(const char **)&pLIn,(const char *)(pLIn+5),off,TRUE, &errorCode);
+         ucnv_toUnicode(cnv, &pUOut,pUOut+UPRV_LENGTHOF(UOut),(const char **)&pLIn,(const char *)(pLIn+5),off,TRUE, &errorCode);

          if (UOut[0] != 0xD801 || errorCode != U_TRUNCATED_CHAR_FOUND || pUOut != UOut + 1 || pLIn != LIn + 5)
          {
             log_err("Unexpected results on chopped low surrogate\n");
          if (UOut[0] != 0xD801 || errorCode != U_TRUNCATED_CHAR_FOUND || pUOut != UOut + 1 || pLIn != LIn + 5)
          {
             log_err("Unexpected results on chopped low surrogate\n");


@@ -5231,7 +5241,7 @@ TestLMBCS() {
          errorCode = U_ZERO_ERROR;
          pUOut = UOut;
 
          errorCode = U_ZERO_ERROR;
          pUOut = UOut;
 

-         ucnv_toUnicode(cnv, &pUOut,pUOut+sizeof(UOut)/sizeof(UChar),(const char **)&pLIn,(const char *)(pLIn+3),off,TRUE, &errorCode);
+         ucnv_toUnicode(cnv, &pUOut,pUOut+UPRV_LENGTHOF(UOut),(const char **)&pLIn,(const char *)(pLIn+3),off,TRUE, &errorCode);

          if (UOut[0] != 0xD801 || U_FAILURE(errorCode) || pUOut != UOut + 1 || pLIn != LIn + 3)
          {
             log_err("Unexpected results on chopped at surrogate boundary \n");
          if (UOut[0] != 0xD801 || U_FAILURE(errorCode) || pUOut != UOut + 1 || pLIn != LIn + 3)
          {
             log_err("Unexpected results on chopped at surrogate boundary \n");


@@ -5248,7 +5258,7 @@ TestLMBCS() {
          errorCode = U_ZERO_ERROR;
          pUOut = UOut;
 
          errorCode = U_ZERO_ERROR;
          pUOut = UOut;
 

-         ucnv_toUnicode(cnv, &pUOut,pUOut+sizeof(UOut)/sizeof(UChar),(const char **)&pLIn,(const char *)(pLIn+6),off,TRUE, &errorCode);
+         ucnv_toUnicode(cnv, &pUOut,pUOut+UPRV_LENGTHOF(UOut),(const char **)&pLIn,(const char *)(pLIn+6),off,TRUE, &errorCode);

          if (UOut[0] != 0xD801 || UOut[1] != 0xC9D0 || U_FAILURE(errorCode) || pUOut != UOut + 2 || pLIn != LIn + 6)
          {
             log_err("Unexpected results after unpaired surrogate plus valid Unichar \n");
          if (UOut[0] != 0xD801 || UOut[1] != 0xC9D0 || U_FAILURE(errorCode) || pUOut != UOut + 2 || pLIn != LIn + 6)
          {
             log_err("Unexpected results after unpaired surrogate plus valid Unichar \n");


@@ -5265,7 +5275,7 @@ TestLMBCS() {
          errorCode = U_ZERO_ERROR;
          pUOut = UOut;
 
          errorCode = U_ZERO_ERROR;
          pUOut = UOut;
 

-         ucnv_toUnicode(cnv, &pUOut,pUOut+sizeof(UOut)/sizeof(UChar),(const char **)&pLIn,(const char *)(pLIn+5),off,TRUE, &errorCode);
+         ucnv_toUnicode(cnv, &pUOut,pUOut+UPRV_LENGTHOF(UOut),(const char **)&pLIn,(const char *)(pLIn+5),off,TRUE, &errorCode);

          if (UOut[0] != 0xD801 || errorCode != U_TRUNCATED_CHAR_FOUND || pUOut != UOut + 1 || pLIn != LIn + 5)
          {
             log_err("Unexpected results after unpaired surrogate plus chopped Unichar \n");
          if (UOut[0] != 0xD801 || errorCode != U_TRUNCATED_CHAR_FOUND || pUOut != UOut + 1 || pLIn != LIn + 5)
          {
             log_err("Unexpected results after unpaired surrogate plus chopped Unichar \n");


@@ -5282,7 +5292,7 @@ TestLMBCS() {
          errorCode = U_ZERO_ERROR;
          pUOut = UOut;
 
          errorCode = U_ZERO_ERROR;
          pUOut = UOut;
 

-         ucnv_toUnicode(cnv, &pUOut,pUOut+sizeof(UOut)/sizeof(UChar),(const char **)&pLIn,(const char *)(pLIn+5),off,TRUE, &errorCode);
+         ucnv_toUnicode(cnv, &pUOut,pUOut+UPRV_LENGTHOF(UOut),(const char **)&pLIn,(const char *)(pLIn+5),off,TRUE, &errorCode);

          if (UOut[0] != 0xD801 || UOut[1] != 0x1B || U_FAILURE(errorCode) || pUOut != UOut + 2 || pLIn != LIn + 5)
          {
             log_err("Unexpected results after unpaired surrogate plus valid non-Unichar\n");
          if (UOut[0] != 0xD801 || UOut[1] != 0x1B || U_FAILURE(errorCode) || pUOut != UOut + 2 || pLIn != LIn + 5)
          {
             log_err("Unexpected results after unpaired surrogate plus valid non-Unichar\n");


@@ -5298,7 +5308,7 @@ TestLMBCS() {
          errorCode = U_ZERO_ERROR;
          pUOut = UOut;
 
          errorCode = U_ZERO_ERROR;
          pUOut = UOut;
 

-         ucnv_toUnicode(cnv, &pUOut,pUOut+sizeof(UOut)/sizeof(UChar),(const char **)&pLIn,(const char *)(pLIn+4),off,TRUE, &errorCode);
+         ucnv_toUnicode(cnv, &pUOut,pUOut+UPRV_LENGTHOF(UOut),(const char **)&pLIn,(const char *)(pLIn+4),off,TRUE, &errorCode);

 
          if (UOut[0] != 0xD801 || errorCode != U_TRUNCATED_CHAR_FOUND || pUOut != UOut + 1 || pLIn != LIn + 4)
          {
 
          if (UOut[0] != 0xD801 || errorCode != U_TRUNCATED_CHAR_FOUND || pUOut != UOut + 1 || pLIn != LIn + 4)
          {


@@ -5397,6 +5407,12 @@ static void TestJitterbug981(){
     }
 
     rules = ucol_getRules(myCollator, &rules_length);
     }
 
     rules = ucol_getRules(myCollator, &rules_length);

+    if(rules_length == 0) {
+        log_data_err("missing zh tailoring rule string\n");
+        ucol_close(myCollator);
+        ucnv_close(utf8cnv);
+        return;
+    }

     buff_size = rules_length * ucnv_getMaxCharSize(utf8cnv);
     buff = malloc(buff_size);
 
     buff_size = rules_length * ucnv_getMaxCharSize(utf8cnv);
     buff = malloc(buff_size);
 


@@ -5491,7 +5507,7 @@ static void TestJB5275_1(){
     }
     targetLimit = target;
     target = dest;
     }
     targetLimit = target;
     target = dest;

-    printUSeq(target, targetLimit-target);
+    printUSeq(target, (int)(targetLimit-target));

     while(target<targetLimit){
         if(*exp!=*target){
             log_err("did not get the expected output. \\u%04X != \\u%04X (got)\n", *exp, *target);
     while(target<targetLimit){
         if(*exp!=*target){
             log_err("did not get the expected output. \\u%04X != \\u%04X (got)\n", *exp, *target);


@@ -5533,12 +5549,12 @@ static void TestJB5275(){
     const UChar* exp = expected;
     ucnv_toUnicode(conv, &target, targetLimit, &source, sourceLimit, NULL, TRUE, &status);
     if(U_FAILURE(status)){
     const UChar* exp = expected;
     ucnv_toUnicode(conv, &target, targetLimit, &source, sourceLimit, NULL, TRUE, &status);
     if(U_FAILURE(status)){

-        log_err("conversion failed: %s \n", u_errorName(status));
+        log_data_err("conversion failed: %s \n", u_errorName(status));

     }
     targetLimit = target;
     target = dest;
 
     }
     targetLimit = target;
     target = dest;
 

-    printUSeq(target, targetLimit-target);
+    printUSeq(target, (int)(targetLimit-target));

     
     while(target<targetLimit){
         if(*exp!=*target){
     
     while(target<targetLimit){
         if(*exp!=*target){


@@ -5569,7 +5585,7 @@ TestIsFixedWidth() {
             "UTF16"
     };
 
             "UTF16"
     };
 

-    for (i = 0; i < LENGTHOF(fixedWidth); i++) {
+    for (i = 0; i < UPRV_LENGTHOF(fixedWidth); i++) {

         cnv = ucnv_open(fixedWidth[i], &status);
         if (cnv == NULL || U_FAILURE(status)) {
             log_data_err("Error open converter: %s - %s \n", fixedWidth[i], u_errorName(status));
         cnv = ucnv_open(fixedWidth[i], &status);
         if (cnv == NULL || U_FAILURE(status)) {
             log_data_err("Error open converter: %s - %s \n", fixedWidth[i], u_errorName(status));


@@ -5582,7 +5598,7 @@ TestIsFixedWidth() {
         ucnv_close(cnv);
     }
 
         ucnv_close(cnv);
     }
 

-    for (i = 0; i < LENGTHOF(notFixedWidth); i++) {
+    for (i = 0; i < UPRV_LENGTHOF(notFixedWidth); i++) {

         cnv = ucnv_open(notFixedWidth[i], &status);
         if (cnv == NULL || U_FAILURE(status)) {
             log_data_err("Error open converter: %s - %s \n", notFixedWidth[i], u_errorName(status));
         cnv = ucnv_open(notFixedWidth[i], &status);
         if (cnv == NULL || U_FAILURE(status)) {
             log_data_err("Error open converter: %s - %s \n", notFixedWidth[i], u_errorName(status));