Update ICU to 54.1 step 1

source/test/cintltst/ncnvtst.c

 /********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 1997-2013, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /*****************************************************************************
 *
 * File CCONVTST.C
 *
 * Modification History:
 *        Name                     Description
 *   Madhu Katragadda              7/7/2000        Converter Tests for extended code coverage
 ******************************************************************************
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "unicode/uloc.h"
 #include "unicode/ucnv.h"
 #include "unicode/utypes.h"
 #include "unicode/ustring.h"
 #include "unicode/uset.h"
 #include "cintltst.h"
+#include "cmemory.h"
 
 #define MAX_LENGTH 999
 
 #define UNICODE_LIMIT 0x10FFFF
 #define SURROGATE_HIGH_START    0xD800
 #define SURROGATE_LOW_END       0xDFFF
 
 static int32_t  gInBufferSize = 0;
 static int32_t  gOutBufferSize = 0;
 static char     gNuConvTestName[1024];
 
 #define nct_min(x,y)  ((x<y) ? x : y)
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
 
 static void printSeq(const unsigned char* a, int len);
 static void printSeqErr(const unsigned char* a, int len);
 static void printUSeq(const UChar* a, int len);
 static void printUSeqErr(const UChar* a, int len);
 static UBool convertFromU( const UChar *source, int sourceLen,  const uint8_t *expect, int expectLen, 
                 const char *codepage, const int32_t *expectOffsets, UBool doFlush, UErrorCode expectedStatus);
 static UBool convertToU( const uint8_t *source, int sourceLen, const UChar *expect, int expectLen, 
                const char *codepage, const int32_t *expectOffsets, UBool doFlush, UErrorCode expectedStatus);
 
@@ skipping 1738 matching lines @@
     if(U_FAILURE(errorCode)) {
         log_data_err("error TestTruncated: unable to set the stop callback on \"%s\" - %s\n",
                     cnvName, u_errorName(errorCode));
         ucnv_close(cnv);
         return;
     }
 
     source=(const char *)bytes;
     sourceLimit=source+length;
     target=buffer;
-    targetLimit=buffer+LENGTHOF(buffer);
+    targetLimit=buffer+UPRV_LENGTHOF(buffer);
 
     /* 1. input bytes with flush=FALSE, then input nothing with flush=TRUE */
     ucnv_toUnicode(cnv, &target, targetLimit, &source, sourceLimit, NULL, FALSE, &errorCode);
     if(U_FAILURE(errorCode) || source!=sourceLimit || target!=buffer) {
         log_err("error TestTruncated(%s, 1a): input bytes[%d], flush=FALSE: %s, input left %d, output %d\n",
                 cnvName, length, u_errorName(errorCode), (int)(sourceLimit-source), (int)(target-buffer));
     }
 
     errorCode=U_ZERO_ERROR;
     source=sourceLimit;
@@ skipping 53 matching lines @@
 
         { "Shift-JIS",  { 0xe0 }, 1 },
 
         { "ibm-939",    { 0x0e, 0x41 }, 2 } /* SO 0x41 */
 #else
         { "BOCU-1",     { 0xd5 }, 1 ,}
 #endif
     };
     int32_t i;
 
-    for(i=0; i<LENGTHOF(testCases); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(testCases); ++i) {
         doTestTruncated(testCases[i].cnvName, testCases[i].bytes, testCases[i].length);
     }
 }
 
 typedef struct NameRange {
     const char *name;
     UChar32 start, end, start2, end2, notStart, notEnd;
 } NameRange;
 
 static void
@@ skipping 74 matching lines @@
             log_err("error: ucnv_getUnicodeSet(%s) failed - %s\n",
                     name, u_errorName(errorCode));
         } else if(uset_size(set)==0) {
             log_err("error: ucnv_getUnicodeSet(%s) returns an empty set\n", name);
         }
 
         ucnv_close(cnv);
     }
 
     /* test converters that are known to convert all of Unicode (except maybe for surrogates) */
-    for(i=0; i<LENGTHOF(completeSetNames); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(completeSetNames); ++i) {
         errorCode=U_ZERO_ERROR;
         name=completeSetNames[i];
         cnv=ucnv_open(name, &errorCode);
         if(U_FAILURE(errorCode)) {
             log_data_err("error: unable to open converter %s - %s\n",
                     name, u_errorName(errorCode));
             continue;
         }
 
         uset_clear(set);
         ucnv_getUnicodeSet(cnv, set, UCNV_ROUNDTRIP_SET, &errorCode);
         if(U_FAILURE(errorCode)) {
             log_err("error: ucnv_getUnicodeSet(%s) failed - %s\n",
                     name, u_errorName(errorCode));
         } else if(!uset_containsRange(set, 0, 0xd7ff) || !uset_containsRange(set, 0xe000, 0x10ffff)) {
             log_err("error: ucnv_getUnicodeSet(%s) does not return an all-Unicode set\n", name);
         }
 
         ucnv_close(cnv);
     }
 
 #if !UCONFIG_NO_LEGACY_CONVERSION
     /* test LMBCS variants which convert all of Unicode except for U+F6xx */
-    for(i=0; i<LENGTHOF(lmbcsNames); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(lmbcsNames); ++i) {
         errorCode=U_ZERO_ERROR;
         name=lmbcsNames[i];
         cnv=ucnv_open(name, &errorCode);
         if(U_FAILURE(errorCode)) {
             log_data_err("error: unable to open converter %s - %s\n",
                     name, u_errorName(errorCode));
             continue;
         }
 
         uset_clear(set);
         ucnv_getUnicodeSet(cnv, set, UCNV_ROUNDTRIP_SET, &errorCode);
         if(U_FAILURE(errorCode)) {
             log_err("error: ucnv_getUnicodeSet(%s) failed - %s\n",
                     name, u_errorName(errorCode));
         } else if(!uset_containsRange(set, 0, 0xf5ff) || !uset_containsRange(set, 0xf700, 0x10ffff)) {
             log_err("error: ucnv_getUnicodeSet(%s) does not return an all-Unicode set (minus U+F6xx)\n", name);
         }
 
         ucnv_close(cnv);
     }
 #endif
 
     /* test specific sets */
-    for(i=0; i<LENGTHOF(nameRanges); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(nameRanges); ++i) {
         errorCode=U_ZERO_ERROR;
         name=nameRanges[i].name;
         cnv=ucnv_open(name, &errorCode);
         if(U_FAILURE(errorCode)) {
             log_data_err("error: unable to open converter %s - %s\n",
                          name, u_errorName(errorCode));
             continue;
         }
 
         uset_clear(set);
@@ skipping 24 matching lines @@
     }
     errorCode = U_PARSE_ERROR;
     /* Make sure that it does nothing if an error is passed in. Difficult to proper test for. */
     ucnv_getUnicodeSet(NULL, NULL, UCNV_ROUNDTRIP_SET, &errorCode);
     if (errorCode != U_PARSE_ERROR) {
         log_err("error: ucnv_getUnicodeSet(NULL) returned wrong status code %s\n", u_errorName(errorCode));
     }
 
     uset_close(set);
 }