From: Fredrik Roubert <roubert@google.com>
Date: Wed, 24 Feb 2016 22:52:29 +0000 (+0000)
Subject: ICU-12012 Replace all sizeof p / U_SIZEOF_... with UPRV_LENGTHOF().
X-Git-Tag: milestone-59-0-1~658
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=f75e591321e8dd0932235b11f943c63ae2fe5715;p=icu

ICU-12012 Replace all sizeof p / U_SIZEOF_... with UPRV_LENGTHOF().

R=markus.icu@gmail.com

Review URL: https://codereview.appspot.com/291740043 .

X-SVN-Rev: 38349
---

diff --git a/icu4c/source/common/ucnv.c b/icu4c/source/common/ucnv.c
index addae158989..79b26549f55 100644
--- a/icu4c/source/common/ucnv.c
+++ b/icu4c/source/common/ucnv.c
@@ -1817,7 +1817,7 @@ ucnv_toUChars(UConverter *cnv,
         {
             UChar buffer[1024];
 
-            destLimit=buffer+sizeof(buffer)/U_SIZEOF_UCHAR;
+            destLimit=buffer+UPRV_LENGTHOF(buffer);
             do {
                 dest=buffer;
                 *pErrorCode=U_ZERO_ERROR;
diff --git a/icu4c/source/extra/uconv/uwmsg.c b/icu4c/source/extra/uconv/uwmsg.c
index a182a719a67..772a7399fc7 100644
--- a/icu4c/source/extra/uconv/uwmsg.c
+++ b/icu4c/source/extra/uconv/uwmsg.c
@@ -1,6 +1,6 @@
 /*
 **********************************************************************
-* Copyright (C) 1998-2014, International Business Machines Corporation
+* Copyright (C) 1998-2016, International Business Machines Corporation
 * and others.  All Rights Reserved.
 **********************************************************************
 *
@@ -19,6 +19,7 @@
 #include "unicode/uwmsg.h"
 #include "unicode/ures.h"
 #include "unicode/putil.h"
+#include "cmemory.h"
 #include "cstring.h"
 
 #include <stdlib.h>
@@ -143,7 +144,7 @@ U_CFUNC int u_wmsg(FILE *fp, const char *tag, ... )
     }
 
 #if UCONFIG_NO_FORMATTING
-    resultLength = sizeof(gNoFormatting) / U_SIZEOF_UCHAR;
+    resultLength = UPRV_LENGTHOF(gNoFormatting);
     if((msgLen + resultLength) <= UPRV_LENGTHOF(result)) {
         memcpy(result, msg, msgLen * U_SIZEOF_UCHAR);
         memcpy(result + msgLen, gNoFormatting, resultLength);
diff --git a/icu4c/source/samples/ucnv/convsamp.cpp b/icu4c/source/samples/ucnv/convsamp.cpp
index fb17f500038..62a61774180 100644
--- a/icu4c/source/samples/ucnv/convsamp.cpp
+++ b/icu4c/source/samples/ucnv/convsamp.cpp
@@ -1,6 +1,6 @@
 /**************************************************************************
 *
-*   Copyright (C) 2000-2013, International Business Machines
+*   Copyright (C) 2000-2016, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 ***************************************************************************
@@ -33,6 +33,7 @@
 #include <string.h>
 #include <stdlib.h>  /* malloc */
 
+#include "cmemory.h"
 #include "unicode/utypes.h"   /* Basic ICU data types */
 #include "unicode/ucnv.h"     /* C   Converter API    */
 #include "unicode/ustring.h"  /* some more string fcns*/
@@ -1086,7 +1087,7 @@ void convsample_50() {
     conv = ucnv_open(encoding, &err);
     // do the conversion
     ucnv_toUnicode(conv,
-                   &target, output + sizeof(output)/U_SIZEOF_UCHAR,
+                   &target, output + UPRV_LENGTHOF(output),
                    &source, input + sizeof(input),
                    NULL, TRUE, &err);
     out = output;
diff --git a/icu4c/source/test/cintltst/cnormtst.c b/icu4c/source/test/cintltst/cnormtst.c
index 37ce281f0c5..4acbc208430 100644
--- a/icu4c/source/test/cintltst/cnormtst.c
+++ b/icu4c/source/test/cintltst/cnormtst.c
@@ -1,6 +1,6 @@
 /********************************************************************
- * COPYRIGHT: 
- * Copyright (c) 1997-2014, International Business Machines Corporation and
+ * COPYRIGHT:
+ * Copyright (c) 1997-2016, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /********************************************************************************
@@ -900,7 +900,7 @@ TestNormCoverage() {
     errorCode=U_ZERO_ERROR;
     length=unorm_normalize(input, inLength,
                            UNORM_NFKC, 0,
-                           output, sizeof(output)/U_SIZEOF_UCHAR,
+                           output, UPRV_LENGTHOF(output),
                            &errorCode);
     if(U_FAILURE(errorCode)) {
         log_data_err("error unorm_normalize(long input, UNORM_NFKC) failed with %s - (Are you missing data?)\n", u_errorName(errorCode));
@@ -940,7 +940,7 @@ TestNormCoverage() {
     errorCode=U_ZERO_ERROR;
     length=unorm_normalize(input, inLength,
                            UNORM_FCD, 0,
-                           output, sizeof(output)/U_SIZEOF_UCHAR,
+                           output, UPRV_LENGTHOF(output),
                            &errorCode);
     if(U_FAILURE(errorCode)) {
         log_data_err("error unorm_normalize(long input, UNORM_FCD) failed with %s - (Are you missing data?)\n", u_errorName(errorCode));
@@ -1055,7 +1055,7 @@ _testIter(const UChar *src, int32_t srcLength,
                 return;
             }
             length=unorm_next(iter,
-                              buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
+                              buffer, UPRV_LENGTHOF(buffer),
                               mode, 0,
                               (UBool)(out!=NULL), &neededToNormalize,
                               &errorCode);
@@ -1080,7 +1080,7 @@ _testIter(const UChar *src, int32_t srcLength,
                 return;
             }
             length=unorm_previous(iter,
-                                  buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
+                                  buffer, UPRV_LENGTHOF(buffer),
                                   mode, 0,
                                   (UBool)(out!=NULL), &neededToNormalize,
                                   &errorCode);
@@ -1185,59 +1185,59 @@ TestNextPrevious() {
     UBool neededToNormalize;
     UErrorCode errorCode;
 
-    uiter_setString(&iter, src, sizeof(src)/U_SIZEOF_UCHAR);
+    uiter_setString(&iter, src, UPRV_LENGTHOF(src));
 
     /* test iteration with doNormalize */
     iter.index=0;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFD, TRUE, nfd, sizeof(nfd)/U_SIZEOF_UCHAR, nfdIndexes, sizeof(nfdIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFD, TRUE, nfd, UPRV_LENGTHOF(nfd), nfdIndexes, sizeof(nfdIndexes)/4);
     iter.index=0;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKD, TRUE, nfkd, sizeof(nfkd)/U_SIZEOF_UCHAR, nfkdIndexes, sizeof(nfkdIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKD, TRUE, nfkd, UPRV_LENGTHOF(nfkd), nfkdIndexes, sizeof(nfkdIndexes)/4);
     iter.index=0;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFC, TRUE, nfc, sizeof(nfc)/U_SIZEOF_UCHAR, nfcIndexes, sizeof(nfcIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFC, TRUE, nfc, UPRV_LENGTHOF(nfc), nfcIndexes, sizeof(nfcIndexes)/4);
     iter.index=0;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKC, TRUE, nfkc, sizeof(nfkc)/U_SIZEOF_UCHAR, nfkcIndexes, sizeof(nfkcIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKC, TRUE, nfkc, UPRV_LENGTHOF(nfkc), nfkcIndexes, sizeof(nfkcIndexes)/4);
     iter.index=0;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_FCD, TRUE, fcd, sizeof(fcd)/U_SIZEOF_UCHAR, fcdIndexes, sizeof(fcdIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_FCD, TRUE, fcd, UPRV_LENGTHOF(fcd), fcdIndexes, sizeof(fcdIndexes)/4);
 
     iter.index=iter.length;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFD, FALSE, nfd, sizeof(nfd)/U_SIZEOF_UCHAR, nfdIndexes, sizeof(nfdIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFD, FALSE, nfd, UPRV_LENGTHOF(nfd), nfdIndexes, sizeof(nfdIndexes)/4);
     iter.index=iter.length;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKD, FALSE, nfkd, sizeof(nfkd)/U_SIZEOF_UCHAR, nfkdIndexes, sizeof(nfkdIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKD, FALSE, nfkd, UPRV_LENGTHOF(nfkd), nfkdIndexes, sizeof(nfkdIndexes)/4);
     iter.index=iter.length;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFC, FALSE, nfc, sizeof(nfc)/U_SIZEOF_UCHAR, nfcIndexes, sizeof(nfcIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFC, FALSE, nfc, UPRV_LENGTHOF(nfc), nfcIndexes, sizeof(nfcIndexes)/4);
     iter.index=iter.length;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKC, FALSE, nfkc, sizeof(nfkc)/U_SIZEOF_UCHAR, nfkcIndexes, sizeof(nfkcIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKC, FALSE, nfkc, UPRV_LENGTHOF(nfkc), nfkcIndexes, sizeof(nfkcIndexes)/4);
     iter.index=iter.length;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_FCD, FALSE, fcd, sizeof(fcd)/U_SIZEOF_UCHAR, fcdIndexes, sizeof(fcdIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_FCD, FALSE, fcd, UPRV_LENGTHOF(fcd), fcdIndexes, sizeof(fcdIndexes)/4);
 
     /* test iteration without doNormalize */
     iter.index=0;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFD, TRUE, NULL, 0, nfdIndexes, sizeof(nfdIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFD, TRUE, NULL, 0, nfdIndexes, sizeof(nfdIndexes)/4);
     iter.index=0;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKD, TRUE, NULL, 0, nfkdIndexes, sizeof(nfkdIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKD, TRUE, NULL, 0, nfkdIndexes, sizeof(nfkdIndexes)/4);
     iter.index=0;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFC, TRUE, NULL, 0, nfcIndexes, sizeof(nfcIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFC, TRUE, NULL, 0, nfcIndexes, sizeof(nfcIndexes)/4);
     iter.index=0;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKC, TRUE, NULL, 0, nfkcIndexes, sizeof(nfkcIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKC, TRUE, NULL, 0, nfkcIndexes, sizeof(nfkcIndexes)/4);
     iter.index=0;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_FCD, TRUE, NULL, 0, fcdIndexes, sizeof(fcdIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_FCD, TRUE, NULL, 0, fcdIndexes, sizeof(fcdIndexes)/4);
 
     iter.index=iter.length;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFD, FALSE, NULL, 0, nfdIndexes, sizeof(nfdIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFD, FALSE, NULL, 0, nfdIndexes, sizeof(nfdIndexes)/4);
     iter.index=iter.length;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKD, FALSE, NULL, 0, nfkdIndexes, sizeof(nfkdIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKD, FALSE, NULL, 0, nfkdIndexes, sizeof(nfkdIndexes)/4);
     iter.index=iter.length;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFC, FALSE, NULL, 0, nfcIndexes, sizeof(nfcIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFC, FALSE, NULL, 0, nfcIndexes, sizeof(nfcIndexes)/4);
     iter.index=iter.length;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKC, FALSE, NULL, 0, nfkcIndexes, sizeof(nfkcIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKC, FALSE, NULL, 0, nfkcIndexes, sizeof(nfkcIndexes)/4);
     iter.index=iter.length;
-    _testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_FCD, FALSE, NULL, 0, fcdIndexes, sizeof(fcdIndexes)/4);
+    _testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_FCD, FALSE, NULL, 0, fcdIndexes, sizeof(fcdIndexes)/4);
 
     /* try without neededToNormalize */
     errorCode=U_ZERO_ERROR;
     buffer[0]=5;
     iter.index=1;
-    length=unorm_next(&iter, buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
+    length=unorm_next(&iter, buffer, UPRV_LENGTHOF(buffer),
                       UNORM_NFD, 0, TRUE, NULL,
                       &errorCode);
     if(U_FAILURE(errorCode) || length!=2 || buffer[0]!=nfd[2] || buffer[1]!=nfd[3]) {
@@ -1273,7 +1273,7 @@ TestNextPrevious() {
     buffer[0]=buffer[1]=5;
     neededToNormalize=9;
     iter.index=1;
-    length=unorm_next(NULL, buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
+    length=unorm_next(NULL, buffer, UPRV_LENGTHOF(buffer),
                       UNORM_NFD, 0, TRUE, &neededToNormalize,
                       &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
@@ -1285,7 +1285,7 @@ TestNextPrevious() {
     buffer[0]=buffer[1]=5;
     neededToNormalize=9;
     iter.index=1;
-    length=unorm_next(&iter, buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
+    length=unorm_next(&iter, buffer, UPRV_LENGTHOF(buffer),
                       (UNormalizationMode)0, 0, TRUE, &neededToNormalize,
                       &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
@@ -1297,7 +1297,7 @@ TestNextPrevious() {
     errorCode=U_MISPLACED_QUANTIFIER;
     buffer[0]=5;
     iter.index=1;
-    length=unorm_next(&iter, buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
+    length=unorm_next(&iter, buffer, UPRV_LENGTHOF(buffer),
                       UNORM_NFD, 0, TRUE, NULL,
                       &errorCode);
     if(errorCode!=U_MISPLACED_QUANTIFIER) {
diff --git a/icu4c/source/test/cintltst/cnumtst.c b/icu4c/source/test/cintltst/cnumtst.c
index e6195fbdbb2..411fcd6a76b 100644
--- a/icu4c/source/test/cintltst/cnumtst.c
+++ b/icu4c/source/test/cintltst/cnumtst.c
@@ -617,7 +617,7 @@ free(result);
         }
     }
     for(i = 0; i < UNUM_FORMAT_SYMBOL_COUNT; ++i) {
-        resultlength = unum_getSymbol(cur_frpattern, (UNumberFormatSymbol)i, symbol, sizeof(symbol)/U_SIZEOF_UCHAR, &status);
+        resultlength = unum_getSymbol(cur_frpattern, (UNumberFormatSymbol)i, symbol, UPRV_LENGTHOF(symbol), &status);
         if(U_FAILURE(status)) {
             log_err("Error from unum_getSymbol(%d): %s\n", i, myErrorName(status));
             return;
@@ -627,7 +627,7 @@ free(result);
         }
     }
     /*try getting from a bogus symbol*/
-    unum_getSymbol(cur_frpattern, (UNumberFormatSymbol)i, symbol, sizeof(symbol)/U_SIZEOF_UCHAR, &status);
+    unum_getSymbol(cur_frpattern, (UNumberFormatSymbol)i, symbol, UPRV_LENGTHOF(symbol), &status);
     if(U_SUCCESS(status)){
         log_err("Error : Expected U_ILLEGAL_ARGUMENT_ERROR for bogus symbol");
     }
diff --git a/icu4c/source/test/cintltst/cstrcase.c b/icu4c/source/test/cintltst/cstrcase.c
index 5f7a6e3114f..4b0aa3fd86d 100644
--- a/icu4c/source/test/cintltst/cstrcase.c
+++ b/icu4c/source/test/cintltst/cstrcase.c
@@ -1,7 +1,7 @@
 /*
 *******************************************************************************
 *
-*   Copyright (C) 2002-2015, International Business Machines
+*   Copyright (C) 2002-2016, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
@@ -44,12 +44,12 @@ TestCaseLower(void) {
     /* lowercase with root locale and separate buffers */
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
-    length=u_strToLower(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
+    length=u_strToLower(buffer, UPRV_LENGTHOF(buffer),
+                        beforeLower, UPRV_LENGTHOF(beforeLower),
                         "",
                         &errorCode);
     if( U_FAILURE(errorCode) ||
-        length!=(sizeof(lowerRoot)/U_SIZEOF_UCHAR) ||
+        length!=(UPRV_LENGTHOF(lowerRoot)) ||
         uprv_memcmp(lowerRoot, buffer, length*U_SIZEOF_UCHAR)!=0 ||
         buffer[length]!=0
     ) {
@@ -64,14 +64,14 @@ buffer[length]==0 ? "yes" : "no",
 
     /* lowercase with turkish locale and in the same buffer */
     uprv_memcpy(buffer, beforeLower, sizeof(beforeLower));
-    buffer[sizeof(beforeLower)/U_SIZEOF_UCHAR]=0;
+    buffer[UPRV_LENGTHOF(beforeLower)]=0;
     errorCode=U_ZERO_ERROR;
-    length=u_strToLower(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
+    length=u_strToLower(buffer, UPRV_LENGTHOF(buffer),
                         buffer, -1, /* implicit srcLength */
                         "tr",
                         &errorCode);
     if( U_FAILURE(errorCode) ||
-        length!=(sizeof(lowerTurkish)/U_SIZEOF_UCHAR) ||
+        length!=(UPRV_LENGTHOF(lowerTurkish)) ||
         uprv_memcmp(lowerTurkish, buffer, length*U_SIZEOF_UCHAR)!=0 ||
         buffer[length]!=0
     ) {
@@ -85,11 +85,11 @@ buffer[length]==0 ? "yes" : "no",
     buffer[0]=buffer[2]=0xabcd;
     errorCode=U_ZERO_ERROR;
     length=u_strToLower(buffer, 2, /* set destCapacity=2 */
-                        beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
+                        beforeLower, UPRV_LENGTHOF(beforeLower),
                         "",
                         &errorCode);
     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
-        length!=(sizeof(lowerRoot)/U_SIZEOF_UCHAR) ||
+        length!=(UPRV_LENGTHOF(lowerRoot)) ||
         uprv_memcmp(lowerRoot, buffer, 2*U_SIZEOF_UCHAR)!=0 ||
         buffer[2]!=0xabcd
     ) {
@@ -101,8 +101,8 @@ buffer[length]==0 ? "yes" : "no",
 
     /* test error handling */
     errorCode=U_ZERO_ERROR;
-    length=u_strToLower(NULL, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
+    length=u_strToLower(NULL, UPRV_LENGTHOF(buffer),
+                        beforeLower, UPRV_LENGTHOF(beforeLower),
                         "",
                         &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
@@ -114,7 +114,7 @@ buffer[length]==0 ? "yes" : "no",
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
     length=u_strToLower(buffer, -1,
-                        beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
+                        beforeLower, UPRV_LENGTHOF(beforeLower),
                         "",
                         &errorCode);
     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
@@ -142,12 +142,12 @@ TestCaseUpper(void) {
     /* uppercase with root locale and in the same buffer */
     uprv_memcpy(buffer, beforeUpper, sizeof(beforeUpper));
     errorCode=U_ZERO_ERROR;
-    length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        buffer, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
+    length=u_strToUpper(buffer, UPRV_LENGTHOF(buffer),
+                        buffer, UPRV_LENGTHOF(beforeUpper),
                         "",
                         &errorCode);
     if( U_FAILURE(errorCode) ||
-        length!=(sizeof(upperRoot)/U_SIZEOF_UCHAR) ||
+        length!=(UPRV_LENGTHOF(upperRoot)) ||
         uprv_memcmp(upperRoot, buffer, length*U_SIZEOF_UCHAR)!=0 ||
         buffer[length]!=0
     ) {
@@ -160,12 +160,12 @@ TestCaseUpper(void) {
     /* uppercase with turkish locale and separate buffers */
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
-    length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        beforeUpper, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
+    length=u_strToUpper(buffer, UPRV_LENGTHOF(buffer),
+                        beforeUpper, UPRV_LENGTHOF(beforeUpper),
                         "tr",
                         &errorCode);
     if( U_FAILURE(errorCode) ||
-        length!=(sizeof(upperTurkish)/U_SIZEOF_UCHAR) ||
+        length!=(UPRV_LENGTHOF(upperTurkish)) ||
         uprv_memcmp(upperTurkish, buffer, length*U_SIZEOF_UCHAR)!=0 ||
         buffer[length]!=0
     ) {
@@ -178,11 +178,11 @@ TestCaseUpper(void) {
     /* test preflighting */
     errorCode=U_ZERO_ERROR;
     length=u_strToUpper(NULL, 0,
-                        beforeUpper, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
+                        beforeUpper, UPRV_LENGTHOF(beforeUpper),
                         "tr",
                         &errorCode);
     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
-        length!=(sizeof(upperTurkish)/U_SIZEOF_UCHAR)
+        length!=(UPRV_LENGTHOF(upperTurkish))
     ) {
         log_err("error in u_strToUpper(turkish locale pure preflighting)=%ld error=%s\n",
             length,
@@ -192,8 +192,8 @@ TestCaseUpper(void) {
     /* test error handling */
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
-    length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        NULL, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
+    length=u_strToUpper(buffer, UPRV_LENGTHOF(buffer),
+                        NULL, UPRV_LENGTHOF(beforeUpper),
                         "tr",
                         &errorCode);
     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
@@ -207,7 +207,7 @@ TestCaseUpper(void) {
 
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
-    length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
+    length=u_strToUpper(buffer, UPRV_LENGTHOF(buffer),
                         beforeUpper, -2,
                         "tr",
                         &errorCode);
@@ -237,7 +237,7 @@ TestCaseTitle(void) {
     UErrorCode errorCode;
 
     errorCode=U_ZERO_ERROR;
-    titleIterChars=ubrk_open(UBRK_CHARACTER, "", beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR, &errorCode);
+    titleIterChars=ubrk_open(UBRK_CHARACTER, "", beforeTitle, UPRV_LENGTHOF(beforeTitle), &errorCode);
     if(U_FAILURE(errorCode)) {
         log_err_status(errorCode, "error: ubrk_open(UBRK_CHARACTER)->%s\n", u_errorName(errorCode));
         return;
@@ -246,12 +246,12 @@ TestCaseTitle(void) {
     /* titlecase with standard break iterator and in the same buffer */
     uprv_memcpy(buffer, beforeTitle, sizeof(beforeTitle));
     errorCode=U_ZERO_ERROR;
-    length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        buffer, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
+    length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer),
+                        buffer, UPRV_LENGTHOF(beforeTitle),
                         NULL, "",
                         &errorCode);
     if( U_FAILURE(errorCode) ||
-        length!=(sizeof(titleWord)/U_SIZEOF_UCHAR) ||
+        length!=(UPRV_LENGTHOF(titleWord)) ||
         uprv_memcmp(titleWord, buffer, length*U_SIZEOF_UCHAR)!=0 ||
         buffer[length]!=0
     ) {
@@ -264,12 +264,12 @@ TestCaseTitle(void) {
     /* titlecase with UBRK_CHARACTERS and separate buffers */
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
-    length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
+    length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer),
+                        beforeTitle, UPRV_LENGTHOF(beforeTitle),
                         titleIterChars, "",
                         &errorCode);
     if( U_FAILURE(errorCode) ||
-        length!=(sizeof(titleChar)/U_SIZEOF_UCHAR) ||
+        length!=(UPRV_LENGTHOF(titleChar)) ||
         uprv_memcmp(titleChar, buffer, length*U_SIZEOF_UCHAR)!=0 ||
         buffer[length]!=0
     ) {
@@ -282,11 +282,11 @@ TestCaseTitle(void) {
     /* test preflighting */
     errorCode=U_ZERO_ERROR;
     length=u_strToTitle(NULL, 0,
-                        beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
+                        beforeTitle, UPRV_LENGTHOF(beforeTitle),
                         titleIterChars, "",
                         &errorCode);
     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
-        length!=(sizeof(titleChar)/U_SIZEOF_UCHAR)
+        length!=(UPRV_LENGTHOF(titleChar))
     ) {
         log_err("error in u_strToTitle(UBRK_CHARACTERS pure preflighting)=%ld error=%s\n",
             length,
@@ -296,8 +296,8 @@ TestCaseTitle(void) {
     /* test error handling */
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
-    length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        NULL, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
+    length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer),
+                        NULL, UPRV_LENGTHOF(beforeTitle),
                         titleIterChars, "",
                         &errorCode);
     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
@@ -311,7 +311,7 @@ TestCaseTitle(void) {
 
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
-    length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
+    length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer),
                         beforeTitle, -2,
                         titleIterChars, "",
                         &errorCode);
@@ -341,7 +341,7 @@ TestCaseDutchTitle(void) {
     UErrorCode errorCode;
 
     errorCode=U_ZERO_ERROR;
-    titleIterWord=ubrk_open(UBRK_WORD, "", beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR, &errorCode);
+    titleIterWord=ubrk_open(UBRK_WORD, "", beforeTitle, UPRV_LENGTHOF(beforeTitle), &errorCode);
     if(U_FAILURE(errorCode)) {
         log_err_status(errorCode, "error: ubrk_open(UBRK_WORD)->%s\n", u_errorName(errorCode));
         return;
@@ -350,12 +350,12 @@ TestCaseDutchTitle(void) {
     /* titlecase with default locale */
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
-    length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
+    length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer),
+                        beforeTitle, UPRV_LENGTHOF(beforeTitle),
                         titleIterWord, "",
                         &errorCode);
     if( U_FAILURE(errorCode) ||
-        length!=(sizeof(titleRoot)/U_SIZEOF_UCHAR) ||
+        length!=(UPRV_LENGTHOF(titleRoot)) ||
         uprv_memcmp(titleRoot, buffer, length*U_SIZEOF_UCHAR)!=0 ||
         buffer[length]!=0
     ) {
@@ -369,12 +369,12 @@ TestCaseDutchTitle(void) {
     /* titlecase with Dutch locale */
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
-    length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
+    length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer),
+                        beforeTitle, UPRV_LENGTHOF(beforeTitle),
                         titleIterWord, "nl",
                         &errorCode);
     if( U_FAILURE(errorCode) ||
-        length!=(sizeof(titleDutch)/U_SIZEOF_UCHAR) ||
+        length!=(UPRV_LENGTHOF(titleDutch)) ||
         uprv_memcmp(titleDutch, buffer, length*U_SIZEOF_UCHAR)!=0 ||
         buffer[length]!=0
     ) {
@@ -456,12 +456,12 @@ TestCaseFolding(void) {
     /* test full string case folding with default option and separate buffers */
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
-    length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
+    length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer),
+                        mixed, UPRV_LENGTHOF(mixed),
                         U_FOLD_CASE_DEFAULT,
                         &errorCode);
     if( U_FAILURE(errorCode) ||
-        length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR) ||
+        length!=(UPRV_LENGTHOF(foldedDefault)) ||
         uprv_memcmp(foldedDefault, buffer, length*U_SIZEOF_UCHAR)!=0 ||
         buffer[length]!=0
     ) {
@@ -475,12 +475,12 @@ TestCaseFolding(void) {
     if(isUnicode_3_1) {
         buffer[0]=0xabcd;
         errorCode=U_ZERO_ERROR;
-        length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                            mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
+        length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer),
+                            mixed, UPRV_LENGTHOF(mixed),
                             U_FOLD_CASE_EXCLUDE_SPECIAL_I,
                             &errorCode);
         if( U_FAILURE(errorCode) ||
-            length!=(sizeof(foldedExcludeSpecialI)/U_SIZEOF_UCHAR) ||
+            length!=(UPRV_LENGTHOF(foldedExcludeSpecialI)) ||
             uprv_memcmp(foldedExcludeSpecialI, buffer, length*U_SIZEOF_UCHAR)!=0 ||
             buffer[length]!=0
         ) {
@@ -493,14 +493,14 @@ TestCaseFolding(void) {
 
     /* test full string case folding with default option and in the same buffer */
     uprv_memcpy(buffer, mixed, sizeof(mixed));
-    buffer[sizeof(mixed)/U_SIZEOF_UCHAR]=0;
+    buffer[UPRV_LENGTHOF(mixed)]=0;
     errorCode=U_ZERO_ERROR;
-    length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
+    length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer),
                         buffer, -1, /* implicit srcLength */
                         U_FOLD_CASE_DEFAULT,
                         &errorCode);
     if( U_FAILURE(errorCode) ||
-        length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR) ||
+        length!=(UPRV_LENGTHOF(foldedDefault)) ||
         uprv_memcmp(foldedDefault, buffer, length*U_SIZEOF_UCHAR)!=0 ||
         buffer[length]!=0
     ) {
@@ -514,12 +514,12 @@ TestCaseFolding(void) {
     if(isUnicode_3_1) {
         uprv_memcpy(buffer, mixed, sizeof(mixed));
         errorCode=U_ZERO_ERROR;
-        length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                            buffer, sizeof(mixed)/U_SIZEOF_UCHAR,
+        length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer),
+                            buffer, UPRV_LENGTHOF(mixed),
                             U_FOLD_CASE_EXCLUDE_SPECIAL_I,
                             &errorCode);
         if( U_FAILURE(errorCode) ||
-            length!=(sizeof(foldedExcludeSpecialI)/U_SIZEOF_UCHAR) ||
+            length!=UPRV_LENGTHOF(foldedExcludeSpecialI) ||
             uprv_memcmp(foldedExcludeSpecialI, buffer, length*U_SIZEOF_UCHAR)!=0 ||
             buffer[length]!=0
         ) {
@@ -534,11 +534,11 @@ TestCaseFolding(void) {
     buffer[0]=buffer[2]=0xabcd;
     errorCode=U_ZERO_ERROR;
     length=u_strFoldCase(buffer, 2, /* set destCapacity=2 */
-                        mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
+                        mixed, UPRV_LENGTHOF(mixed),
                         U_FOLD_CASE_DEFAULT,
                         &errorCode);
     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
-        length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR) ||
+        length!=UPRV_LENGTHOF(foldedDefault) ||
         uprv_memcmp(foldedDefault, buffer, 2*U_SIZEOF_UCHAR)!=0 ||
         buffer[2]!=0xabcd
     ) {
@@ -550,11 +550,11 @@ TestCaseFolding(void) {
 
     errorCode=U_ZERO_ERROR;
     length=u_strFoldCase(NULL, 0,
-                        mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
+                        mixed, UPRV_LENGTHOF(mixed),
                         U_FOLD_CASE_DEFAULT,
                         &errorCode);
     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
-        length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR)
+        length!=UPRV_LENGTHOF(foldedDefault)
     ) {
         log_err("error in u_strFoldCase(default pure preflighting)=%ld error=%s\n",
             length,
@@ -563,8 +563,8 @@ TestCaseFolding(void) {
 
     /* test error handling */
     errorCode=U_ZERO_ERROR;
-    length=u_strFoldCase(NULL, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
+    length=u_strFoldCase(NULL, UPRV_LENGTHOF(buffer),
+                        mixed, UPRV_LENGTHOF(mixed),
                         U_FOLD_CASE_DEFAULT,
                         &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
@@ -576,7 +576,7 @@ TestCaseFolding(void) {
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
     length=u_strFoldCase(buffer, -1,
-                        mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
+                        mixed, UPRV_LENGTHOF(mixed),
                         U_FOLD_CASE_DEFAULT,
                         &errorCode);
     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
@@ -590,8 +590,8 @@ TestCaseFolding(void) {
 
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
-    length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
-                        NULL, sizeof(mixed)/U_SIZEOF_UCHAR,
+    length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer),
+                        NULL, UPRV_LENGTHOF(mixed),
                         U_FOLD_CASE_EXCLUDE_SPECIAL_I,
                         &errorCode);
     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
@@ -605,7 +605,7 @@ TestCaseFolding(void) {
 
     buffer[0]=0xabcd;
     errorCode=U_ZERO_ERROR;
-    length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
+    length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer),
                         mixed, -2,
                         U_FOLD_CASE_EXCLUDE_SPECIAL_I,
                         &errorCode);
diff --git a/icu4c/source/test/cintltst/nccbtst.c b/icu4c/source/test/cintltst/nccbtst.c
index c4eccf0a0a9..8438197f8a7 100644
--- a/icu4c/source/test/cintltst/nccbtst.c
+++ b/icu4c/source/test/cintltst/nccbtst.c
@@ -199,7 +199,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
         static const int32_t fromUOffsets[] = { 0, 2, 3, 3, 3, 5, 5, 6, 6, 8, 8, 8, 8 };
 
         /* test ibm-930 (EBCDIC_STATEFUL) with fallbacks that are not taken to check correct state transitions */
-        if(!testConvertFromUnicode(fromU, sizeof(fromU)/U_SIZEOF_UCHAR,
+        if(!testConvertFromUnicode(fromU, UPRV_LENGTHOF(fromU),
                                    fromUBytes, sizeof(fromUBytes),
                                    "ibm-930",
                                    UCNV_FROM_U_CALLBACK_SKIP, fromUOffsets,
@@ -220,7 +220,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
         static const int32_t latin1FromUOffsets[] = { 0, 1, 3, 6 };
 
         /* US-ASCII */
-        if(!testConvertFromUnicode(usasciiFromU, sizeof(usasciiFromU)/U_SIZEOF_UCHAR,
+        if(!testConvertFromUnicode(usasciiFromU, UPRV_LENGTHOF(usasciiFromU),
                                    usasciiFromUBytes, sizeof(usasciiFromUBytes),
                                    "US-ASCII",
                                    UCNV_FROM_U_CALLBACK_SKIP, usasciiFromUOffsets,
@@ -231,7 +231,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
 
 #if !UCONFIG_NO_LEGACY_CONVERSION
         /* SBCS NLTC codepage 367 for US-ASCII */
-        if(!testConvertFromUnicode(usasciiFromU, sizeof(usasciiFromU)/U_SIZEOF_UCHAR,
+        if(!testConvertFromUnicode(usasciiFromU, UPRV_LENGTHOF(usasciiFromU),
                                    usasciiFromUBytes, sizeof(usasciiFromUBytes),
                                    "ibm-367",
                                    UCNV_FROM_U_CALLBACK_SKIP, usasciiFromUOffsets,
@@ -242,7 +242,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
 #endif
 
         /* ISO-Latin-1 */
-        if(!testConvertFromUnicode(latin1FromU, sizeof(latin1FromU)/U_SIZEOF_UCHAR,
+        if(!testConvertFromUnicode(latin1FromU, UPRV_LENGTHOF(latin1FromU),
                                    latin1FromUBytes, sizeof(latin1FromUBytes),
                                    "LATIN_1",
                                    UCNV_FROM_U_CALLBACK_SKIP, latin1FromUOffsets,
@@ -253,7 +253,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
 
 #if !UCONFIG_NO_LEGACY_CONVERSION
         /* windows-1252 */
-        if(!testConvertFromUnicode(latin1FromU, sizeof(latin1FromU)/U_SIZEOF_UCHAR,
+        if(!testConvertFromUnicode(latin1FromU, UPRV_LENGTHOF(latin1FromU),
                                    latin1FromUBytes, sizeof(latin1FromUBytes),
                                    "windows-1252",
                                    UCNV_FROM_U_CALLBACK_SKIP, latin1FromUOffsets,
@@ -694,7 +694,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
 
         /* US-ASCII */
         if(!testConvertToUnicode(usasciiToUBytes, sizeof(usasciiToUBytes),
-                                 usasciiToU, sizeof(usasciiToU)/U_SIZEOF_UCHAR,
+                                 usasciiToU, UPRV_LENGTHOF(usasciiToU),
                                  "US-ASCII",
                                  UCNV_TO_U_CALLBACK_SKIP, usasciiToUOffsets,
                                  NULL, 0)
@@ -705,7 +705,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
 #if !UCONFIG_NO_LEGACY_CONVERSION
         /* SBCS NLTC codepage 367 for US-ASCII */
         if(!testConvertToUnicode(usasciiToUBytes, sizeof(usasciiToUBytes),
-                                 usasciiToU, sizeof(usasciiToU)/U_SIZEOF_UCHAR,
+                                 usasciiToU, UPRV_LENGTHOF(usasciiToU),
                                  "ibm-367",
                                  UCNV_TO_U_CALLBACK_SKIP, usasciiToUOffsets,
                                  NULL, 0)
@@ -716,7 +716,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
 
         /* ISO-Latin-1 */
         if(!testConvertToUnicode(latin1ToUBytes, sizeof(latin1ToUBytes),
-                                 latin1ToU, sizeof(latin1ToU)/U_SIZEOF_UCHAR,
+                                 latin1ToU, UPRV_LENGTHOF(latin1ToU),
                                  "LATIN_1",
                                  UCNV_TO_U_CALLBACK_SKIP, latin1ToUOffsets,
                                  NULL, 0)
@@ -727,7 +727,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
 #if !UCONFIG_NO_LEGACY_CONVERSION
         /* windows-1252 */
         if(!testConvertToUnicode(latin1ToUBytes, sizeof(latin1ToUBytes),
-                                 latin1ToU, sizeof(latin1ToU)/U_SIZEOF_UCHAR,
+                                 latin1ToU, UPRV_LENGTHOF(latin1ToU),
                                  "windows-1252",
                                  UCNV_TO_U_CALLBACK_SKIP, latin1ToUOffsets,
                                  NULL, 0)
diff --git a/icu4c/source/test/cintltst/nucnvtst.c b/icu4c/source/test/cintltst/nucnvtst.c
index 184bcfb31b8..01677f16b73 100644
--- a/icu4c/source/test/cintltst/nucnvtst.c
+++ b/icu4c/source/test/cintltst/nucnvtst.c
@@ -1014,13 +1014,13 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
             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);
     }
 
     /*
@@ -1094,9 +1094,9 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
             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*/
@@ -1546,7 +1546,7 @@ static void TestAmbiguous()
         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");
@@ -1555,7 +1555,7 @@ static void TestAmbiguous()
         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");
@@ -3276,7 +3276,7 @@ TestISCII(){
         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));    
 
 }
diff --git a/icu4c/source/test/cintltst/utf16tst.c b/icu4c/source/test/cintltst/utf16tst.c
index bf0954d686d..05b79d706c1 100644
--- a/icu4c/source/test/cintltst/utf16tst.c
+++ b/icu4c/source/test/cintltst/utf16tst.c
@@ -147,8 +147,8 @@ static void TestGetChar()
     uint16_t i=0;
     UChar32 c;
     uint16_t offset=0;
-    for(offset=0; offset<sizeof(input)/U_SIZEOF_UCHAR; offset++) {
-        if(0<offset && offset<sizeof(input)/U_SIZEOF_UCHAR-1){
+    for(offset=0; offset<UPRV_LENGTHOF(input); offset++) {
+        if(0<offset && offset<UPRV_LENGTHOF(input)-1){
             UTF16_GET_CHAR_UNSAFE(input, offset, c);
             if(c != result[i]){
                 log_err("ERROR: UTF16_GET_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i], c);
@@ -160,17 +160,17 @@ static void TestGetChar()
             }
         }
 
-        UTF16_GET_CHAR_SAFE(input, 0, offset, sizeof(input)/U_SIZEOF_UCHAR, c, FALSE);
+        UTF16_GET_CHAR_SAFE(input, 0, offset, UPRV_LENGTHOF(input), c, FALSE);
         if(c != result[i+1]){
             log_err("ERROR: UTF16_GET_CHAR_SAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+1], c);
         }
 
-        U16_GET(input, 0, offset, sizeof(input)/U_SIZEOF_UCHAR, c);
+        U16_GET(input, 0, offset, UPRV_LENGTHOF(input), c);
         if(c != result[i+1]){
             log_err("ERROR: U16_GET failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+1], c);
         }
 
-        UTF16_GET_CHAR_SAFE(input, 0, offset, sizeof(input)/U_SIZEOF_UCHAR, c, TRUE);
+        UTF16_GET_CHAR_SAFE(input, 0, offset, UPRV_LENGTHOF(input), c, TRUE);
         if(c != result[i+2]){
             log_err("ERROR: UTF16_GET_CHAR_SAFE(strict) failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+2], c);
         }
@@ -217,7 +217,7 @@ static void TestNextPrevChar(){
     UChar32 c=0x0000;
     uint16_t i=0;
     uint16_t offset=0, setOffset=0;
-    for(offset=0; offset<sizeof(input)/U_SIZEOF_UCHAR; offset++){
+    for(offset=0; offset<UPRV_LENGTHOF(input); offset++){
          setOffset=offset;
          UTF16_NEXT_CHAR_UNSAFE(input, setOffset, c);
          if(setOffset != movedOffset[i]){
@@ -239,7 +239,7 @@ static void TestNextPrevChar(){
          }
 
          setOffset=offset;
-         UTF16_NEXT_CHAR_SAFE(input, setOffset, sizeof(input)/U_SIZEOF_UCHAR, c, FALSE);
+         UTF16_NEXT_CHAR_SAFE(input, setOffset, UPRV_LENGTHOF(input), c, FALSE);
          if(setOffset != movedOffset[i+1]){
              log_err("ERROR: UTF16_NEXT_CHAR_SAFE failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
                  offset, movedOffset[i+1], setOffset);
@@ -249,7 +249,7 @@ static void TestNextPrevChar(){
          }
 
          setOffset=offset;
-         U16_NEXT(input, setOffset, sizeof(input)/U_SIZEOF_UCHAR, c);
+         U16_NEXT(input, setOffset, UPRV_LENGTHOF(input), c);
          if(setOffset != movedOffset[i+1]){
              log_err("ERROR: U16_NEXT failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
                  offset, movedOffset[i+1], setOffset);
@@ -259,7 +259,7 @@ static void TestNextPrevChar(){
          }
 
          setOffset=offset;
-         UTF16_NEXT_CHAR_SAFE(input, setOffset, sizeof(input)/U_SIZEOF_UCHAR, c, TRUE);
+         UTF16_NEXT_CHAR_SAFE(input, setOffset, UPRV_LENGTHOF(input), c, TRUE);
          if(setOffset != movedOffset[i+1]){
              log_err("ERROR: UTF16_NEXT_CHAR_SAFE(strict) failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
                  offset, movedOffset[i+2], setOffset);
@@ -271,7 +271,7 @@ static void TestNextPrevChar(){
          i=(uint16_t)(i+6);
     }
     i=0;
-    for(offset=(uint16_t)sizeof(input)/U_SIZEOF_UCHAR; offset > 0; --offset){
+    for(offset=(uint16_t)UPRV_LENGTHOF(input); offset > 0; --offset){
          setOffset=offset;
          UTF16_PREV_CHAR_UNSAFE(input, setOffset, c);
          if(setOffset != movedOffset[i+3]){
@@ -408,7 +408,7 @@ static void TestFwdBack(){
 
     uint16_t offunsafe=0, offsafe=0;
     uint16_t i=0;
-    while(offunsafe < sizeof(input)/U_SIZEOF_UCHAR){
+    while(offunsafe < UPRV_LENGTHOF(input)){
         UTF16_FWD_1_UNSAFE(input, offunsafe);
         if(offunsafe != fwd_unsafe[i]){
             log_err("ERROR: Forward_unsafe offset expected:%d, Got:%d\n", fwd_unsafe[i], offunsafe);
@@ -418,7 +418,7 @@ static void TestFwdBack(){
 
     offunsafe=0, offsafe=0;
     i=0;
-    while(offunsafe < sizeof(input)/U_SIZEOF_UCHAR){
+    while(offunsafe < UPRV_LENGTHOF(input)){
         U16_FWD_1_UNSAFE(input, offunsafe);
         if(offunsafe != fwd_unsafe[i]){
             log_err("ERROR: U16_FWD_1_UNSAFE offset expected:%d, Got:%d\n", fwd_unsafe[i], offunsafe);
@@ -427,8 +427,8 @@ static void TestFwdBack(){
     }
 
     i=0;
-    while(offsafe < sizeof(input)/U_SIZEOF_UCHAR){
-        UTF16_FWD_1_SAFE(input, offsafe, sizeof(input)/U_SIZEOF_UCHAR);
+    while(offsafe < UPRV_LENGTHOF(input)){
+        UTF16_FWD_1_SAFE(input, offsafe, UPRV_LENGTHOF(input));
         if(offsafe != fwd_safe[i]){
             log_err("ERROR: Forward_safe offset expected:%d, Got:%d\n", fwd_safe[i], offsafe);
         }
@@ -436,16 +436,16 @@ static void TestFwdBack(){
     }
 
     i=0;
-    while(offsafe < sizeof(input)/U_SIZEOF_UCHAR){
-        U16_FWD_1(input, offsafe, sizeof(input)/U_SIZEOF_UCHAR);
+    while(offsafe < UPRV_LENGTHOF(input)){
+        U16_FWD_1(input, offsafe, UPRV_LENGTHOF(input));
         if(offsafe != fwd_safe[i]){
             log_err("ERROR: U16_FWD_1 offset expected:%d, Got:%d\n", fwd_safe[i], offsafe);
         }
         i++;
     }
 
-    offunsafe=sizeof(input)/U_SIZEOF_UCHAR;
-    offsafe=sizeof(input)/U_SIZEOF_UCHAR;
+    offunsafe=UPRV_LENGTHOF(input);
+    offsafe=UPRV_LENGTHOF(input);
     i=0;
     while(offunsafe > 0){
         UTF16_BACK_1_UNSAFE(input, offunsafe);
@@ -455,8 +455,8 @@ static void TestFwdBack(){
         i++;
     }
 
-    offunsafe=sizeof(input)/U_SIZEOF_UCHAR;
-    offsafe=sizeof(input)/U_SIZEOF_UCHAR;
+    offunsafe=UPRV_LENGTHOF(input);
+    offsafe=UPRV_LENGTHOF(input);
     i=0;
     while(offunsafe > 0){
         U16_BACK_1_UNSAFE(input, offunsafe);
@@ -503,7 +503,7 @@ static void TestFwdBack(){
 
     offsafe=0;
     for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
-        UTF16_FWD_N_SAFE(input, offsafe, sizeof(input)/U_SIZEOF_UCHAR, Nvalue[i]);
+        UTF16_FWD_N_SAFE(input, offsafe, UPRV_LENGTHOF(input), Nvalue[i]);
         if(offsafe != fwd_N_safe[i]){
             log_err("ERROR: Forward_N_safe offset expected:%d, Got:%d\n", fwd_N_safe[i], offsafe);
         }
@@ -512,14 +512,14 @@ static void TestFwdBack(){
 
     offsafe=0;
     for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
-        U16_FWD_N(input, offsafe, sizeof(input)/U_SIZEOF_UCHAR, Nvalue[i]);
+        U16_FWD_N(input, offsafe, UPRV_LENGTHOF(input), Nvalue[i]);
         if(offsafe != fwd_N_safe[i]){
             log_err("ERROR: U16_FWD_N offset expected:%d, Got:%d\n", fwd_N_safe[i], offsafe);
         }
     
     }
 
-    offunsafe=sizeof(input)/U_SIZEOF_UCHAR;
+    offunsafe=UPRV_LENGTHOF(input);
     for(i=0; i<UPRV_LENGTHOF(Nvalue)-2; i++){
         UTF16_BACK_N_UNSAFE(input, offunsafe, Nvalue[i]);
         if(offunsafe != back_N_unsafe[i]){
@@ -527,7 +527,7 @@ static void TestFwdBack(){
         }
     }
 
-    offunsafe=sizeof(input)/U_SIZEOF_UCHAR;
+    offunsafe=UPRV_LENGTHOF(input);
     for(i=0; i<UPRV_LENGTHOF(Nvalue)-2; i++){
         U16_BACK_N_UNSAFE(input, offunsafe, Nvalue[i]);
         if(offunsafe != back_N_unsafe[i]){
@@ -535,7 +535,7 @@ static void TestFwdBack(){
         }
     }
 
-    offsafe=sizeof(input)/U_SIZEOF_UCHAR;
+    offsafe=UPRV_LENGTHOF(input);
     for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
         UTF16_BACK_N_SAFE(input, 0, offsafe, Nvalue[i]);
         if(offsafe != back_N_safe[i]){
@@ -543,7 +543,7 @@ static void TestFwdBack(){
         }
     }
 
-    offsafe=sizeof(input)/U_SIZEOF_UCHAR;
+    offsafe=UPRV_LENGTHOF(input);
     for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
         U16_BACK_N(input, 0, offsafe, Nvalue[i]);
         if(offsafe != back_N_safe[i]){
@@ -561,7 +561,7 @@ static void TestSetChar(){
     
     uint16_t i=0;
     uint16_t offset=0, setOffset=0;
-    for(offset=0; offset<sizeof(input)/U_SIZEOF_UCHAR; offset++){
+    for(offset=0; offset<UPRV_LENGTHOF(input); offset++){
          setOffset=offset;
          UTF16_SET_CHAR_START_UNSAFE(input, setOffset);
          if(setOffset != start_unsafe[i]){
@@ -601,7 +601,7 @@ static void TestSetChar(){
          }
 
          setOffset=offset; 
-         U16_SET_CP_LIMIT(input,0, setOffset, sizeof(input)/U_SIZEOF_UCHAR);
+         U16_SET_CP_LIMIT(input,0, setOffset, UPRV_LENGTHOF(input));
          if(setOffset != limit_safe[i]){
              log_err("ERROR: U16_SET_CHAR_LIMIT failed for offset=%ld. Expected:%lx Got:%lx\n", offset, limit_safe[i], setOffset);
          }
diff --git a/icu4c/source/test/intltest/strcase.cpp b/icu4c/source/test/intltest/strcase.cpp
index 01d8db9bd1e..3392a8fdfc2 100644
--- a/icu4c/source/test/intltest/strcase.cpp
+++ b/icu4c/source/test/intltest/strcase.cpp
@@ -1,7 +1,7 @@
 /*
 *******************************************************************************
 *
-*   Copyright (C) 2002-2014, International Business Machines
+*   Copyright (C) 2002-2016, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
@@ -138,48 +138,48 @@ StringCaseTest::TestCaseConversion()
         UnicodeString s;
 
         /* lowercase with root locale */
-        s=UnicodeString(FALSE, beforeLower, (int32_t)(sizeof(beforeLower)/U_SIZEOF_UCHAR));
+        s=UnicodeString(FALSE, beforeLower, UPRV_LENGTHOF(beforeLower));
         s.toLower("");
-        if( s.length()!=(sizeof(lowerRoot)/U_SIZEOF_UCHAR) ||
+        if( s.length()!=UPRV_LENGTHOF(lowerRoot) ||
             s!=UnicodeString(FALSE, lowerRoot, s.length())
         ) {
-            errln("error in toLower(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, lowerRoot, (int32_t)(sizeof(lowerRoot)/U_SIZEOF_UCHAR)) + "\"");
+            errln("error in toLower(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, lowerRoot, UPRV_LENGTHOF(lowerRoot)) + "\"");
         }
 
         /* lowercase with turkish locale */
-        s=UnicodeString(FALSE, beforeLower, (int32_t)(sizeof(beforeLower)/U_SIZEOF_UCHAR));
+        s=UnicodeString(FALSE, beforeLower, UPRV_LENGTHOF(beforeLower));
         s.setCharAt(0, beforeLower[0]).toLower(Locale("tr"));
-        if( s.length()!=(sizeof(lowerTurkish)/U_SIZEOF_UCHAR) ||
+        if( s.length()!=UPRV_LENGTHOF(lowerTurkish) ||
             s!=UnicodeString(FALSE, lowerTurkish, s.length())
         ) {
-            errln("error in toLower(turkish locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, lowerTurkish, (int32_t)(sizeof(lowerTurkish)/U_SIZEOF_UCHAR)) + "\"");
+            errln("error in toLower(turkish locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, lowerTurkish, UPRV_LENGTHOF(lowerTurkish)) + "\"");
         }
 
         /* uppercase with root locale */
-        s=UnicodeString(FALSE, beforeUpper, (int32_t)(sizeof(beforeUpper)/U_SIZEOF_UCHAR));
+        s=UnicodeString(FALSE, beforeUpper, UPRV_LENGTHOF(beforeUpper));
         s.setCharAt(0, beforeUpper[0]).toUpper(Locale(""));
-        if( s.length()!=(sizeof(upperRoot)/U_SIZEOF_UCHAR) ||
+        if( s.length()!=UPRV_LENGTHOF(upperRoot) ||
             s!=UnicodeString(FALSE, upperRoot, s.length())
         ) {
-            errln("error in toUpper(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, upperRoot, (int32_t)(sizeof(upperRoot)/U_SIZEOF_UCHAR)) + "\"");
+            errln("error in toUpper(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, upperRoot, UPRV_LENGTHOF(upperRoot)) + "\"");
         }
 
         /* uppercase with turkish locale */
-        s=UnicodeString(FALSE, beforeUpper, (int32_t)(sizeof(beforeUpper)/U_SIZEOF_UCHAR));
+        s=UnicodeString(FALSE, beforeUpper, UPRV_LENGTHOF(beforeUpper));
         s.toUpper(Locale("tr"));
-        if( s.length()!=(sizeof(upperTurkish)/U_SIZEOF_UCHAR) ||
+        if( s.length()!=UPRV_LENGTHOF(upperTurkish) ||
             s!=UnicodeString(FALSE, upperTurkish, s.length())
         ) {
-            errln("error in toUpper(turkish locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, upperTurkish, (int32_t)(sizeof(upperTurkish)/U_SIZEOF_UCHAR)) + "\"");
+            errln("error in toUpper(turkish locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, upperTurkish, UPRV_LENGTHOF(upperTurkish)) + "\"");
         }
 
         /* uppercase a short string with root locale */
-        s=UnicodeString(FALSE, beforeMiniUpper, (int32_t)(sizeof(beforeMiniUpper)/U_SIZEOF_UCHAR));
+        s=UnicodeString(FALSE, beforeMiniUpper, UPRV_LENGTHOF(beforeMiniUpper));
         s.setCharAt(0, beforeMiniUpper[0]).toUpper("");
-        if( s.length()!=(sizeof(miniUpper)/U_SIZEOF_UCHAR) ||
+        if( s.length()!=UPRV_LENGTHOF(miniUpper) ||
             s!=UnicodeString(FALSE, miniUpper, s.length())
         ) {
-            errln("error in toUpper(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, miniUpper, (int32_t)(sizeof(miniUpper)/U_SIZEOF_UCHAR)) + "\"");
+            errln("error in toUpper(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, miniUpper, UPRV_LENGTHOF(miniUpper)) + "\"");
         }
     }