Update ICU to 54.1 step 1

source/test/cintltst/ccapitst.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 CU_CAPITST.C
 *
 * Modification History:
 *        Name                      Description            
 *     Madhu Katragadda              Ported for C API
 ******************************************************************************
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include "unicode/uloc.h"
 #include "unicode/ucnv.h"
 #include "unicode/ucnv_err.h"
 #include "unicode/putil.h"
 #include "unicode/uset.h"
 #include "unicode/ustring.h"
 #include "ucnv_bld.h" /* for sizeof(UConverter) */
 #include "cmemory.h"  /* for UAlignedMemory */
 #include "cintltst.h"
 #include "ccapitst.h"
 #include "cstring.h"
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
 #define NUM_CODEPAGE 1
 #define MAX_FILE_LEN 1024*20
 #define UCS_FILE_NAME_SIZE 512
 
 /*returns an action other than the one provided*/
 #if !UCONFIG_NO_LEGACY_CONVERSION
 static UConverterFromUCallback otherUnicodeAction(UConverterFromUCallback MIA);
 static UConverterToUCallback otherCharAction(UConverterToUCallback MIA);
 #endif
 
@@ skipping 787 matching lines @@
         }
         /*testing ucnv_getPlatform() with err != U_ZERO_ERROR*/
         err= U_ILLEGAL_ARGUMENT_ERROR;
         if(ucnv_getPlatform(myConverter, &err) != UCNV_UNKNOWN){
             log_err("ucnv)getPlatform with err != U_ZERO_ERROR is supposed to fail\n");
         }
         err=U_ZERO_ERROR;
 
 
         /*Reads the BOM*/
-        fread(&BOM, sizeof(UChar), 1, ucs_file_in);
+        {
+            // Note: gcc produces a compile warning if the return value from fread() is ignored.
+            size_t numRead = fread(&BOM, sizeof(UChar), 1, ucs_file_in);
+            (void)numRead;
+        }
         if (BOM!=0xFEFF && BOM!=0xFFFE) 
         {
             log_err("File Missing BOM...Bailing!\n");
             fclose(ucs_file_in);
             break;
         }
 
 
         /*Reads in the file*/
         while(!feof(ucs_file_in)&&(i+=fread(ucs_file_buffer+i, sizeof(UChar), 1, ucs_file_in)))
@@ skipping 818 matching lines @@
         "UTF-7",
 #if !UCONFIG_NO_LEGACY_CONVERSION
         "IMAP-mailbox-name",
         "ibm-1047-s390"
 #else
         "IMAP=mailbox-name"
 #endif
     };
 
     /* store the actual sizes of each converter */
-    int32_t actualSizes[LENGTHOF(names)];
+    int32_t actualSizes[UPRV_LENGTHOF(names)];
 
     static const int32_t bufferSizes[] = {
         U_CNV_SAFECLONE_BUFFERSIZE,
         (int32_t)(3*sizeof(UConverter))/2,  /* 1.5*sizeof(UConverter) */
         (int32_t)sizeof(UConverter)/2       /* 0.5*sizeof(UConverter) */
     };
 
     char charBuffer[21];   /* Leave at an odd number for alignment testing */
     uint8_t buffer[3] [U_CNV_SAFECLONE_BUFFERSIZE];
     int32_t bufferSize, maxBufferSize;
@@ skipping 93 matching lines @@
         }
 
         ucnv_close(cnv);
     }
 
     maxBufferSize = 0;
     maxName = "";
 
     /* Do these cloned converters work at all - shuffle UChars to chars & back again..*/
 
-    for(j = 0; j < LENGTHOF(bufferSizes); ++j) {
-        for (idx = 0; idx < LENGTHOF(names); idx++)
+    for(j = 0; j < UPRV_LENGTHOF(bufferSizes); ++j) {
+        for (idx = 0; idx < UPRV_LENGTHOF(names); idx++)
         {
             err = U_ZERO_ERROR;
             cnv = ucnv_open(names[idx], &err);
             if(U_FAILURE(err)) {
                 log_data_err("ucnv_open(\"%s\") failed - %s\n", names[idx], u_errorName(err));
                 continue;
             }
 
             if(j == 0) {
                 /* preflight to get maxBufferSize */
@@ skipping 703 matching lines @@
 
     UErrorCode errorCode;
     int32_t i;
 
     /* test truncated sequences */
     errorCode=U_ZERO_ERROR;
     ucnv_setToUCallBack(utf8Cnv, UCNV_TO_U_CALLBACK_STOP, NULL, NULL, NULL, &errorCode);
 
     memcpy(utf8, charUTF8, charUTF8Length);
 
-    for(i=0; i<LENGTHOF(badUTF8); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(badUTF8); ++i) {
         /* truncated sequence? */
         int32_t length=strlen(badUTF8[i]);
         if(length>=(1+U8_COUNT_TRAIL_BYTES(badUTF8[i][0]))) {
             continue;
         }
 
         /* assemble a string with the test character and the truncated sequence */
         memcpy(utf8+charUTF8Length, badUTF8[i], length);
         utf8Length=charUTF8Length+length;
 
         /* convert and check the invalidChars */
         source=utf8;
         target=output;
         pivotSource=pivotTarget=pivotBuffer;
         errorCode=U_ZERO_ERROR;
         ucnv_convertEx(cnv, utf8Cnv,
                        &target, output+sizeof(output),
                        &source, utf8+utf8Length,
-                       pivotBuffer, &pivotSource, &pivotTarget, pivotBuffer+LENGTHOF(pivotBuffer),
+                       pivotBuffer, &pivotSource, &pivotTarget, pivotBuffer+UPRV_LENGTHOF(pivotBuffer),
                        TRUE, TRUE, /* reset & flush */
                        &errorCode);
         outputLength=(int32_t)(target-output);
         (void)outputLength;   /* Suppress set but not used warning. */
         if(errorCode!=U_TRUNCATED_CHAR_FOUND || pivotSource!=pivotBuffer) {
             log_err("unexpected error %s from %s badUTF8[%ld]\n", u_errorName(errorCode), converterName, (long)i);
             continue;
         }
 
         errorCode=U_ZERO_ERROR;
@@ skipping 24 matching lines @@
      * assemble an input string with the test character between each
      * bad sequence,
      * and an expected string with repeated test character output
      */
     memcpy(utf8, charUTF8, charUTF8Length);
     utf8Length=charUTF8Length;
 
     memcpy(expect, char0, char0Length);
     expectLength=char0Length;
 
-    for(i=0; i<LENGTHOF(badUTF8); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(badUTF8); ++i) {
         int32_t length=strlen(badUTF8[i]);
         memcpy(utf8+utf8Length, badUTF8[i], length);
         utf8Length+=length;
 
         memcpy(utf8+utf8Length, charUTF8, charUTF8Length);
         utf8Length+=charUTF8Length;
 
         memcpy(expect+expectLength, char1, char1Length);
         expectLength+=char1Length;
     }
@@ skipping 29 matching lines @@
     char charUTF8[4], char0[8], char1[8];
     int32_t charUTF8Length, char0Length, char1Length;
 
     errorCode=U_ZERO_ERROR;
     utf8Cnv=ucnv_open("UTF-8", &errorCode);
     if(U_FAILURE(errorCode)) {
         log_data_err("unable to open UTF-8 converter - %s\n", u_errorName(errorCode));
         return;
     }
 
-    for(i=0; i<LENGTHOF(converterNames); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(converterNames); ++i) {
         errorCode=U_ZERO_ERROR;
         cnv=ucnv_open(converterNames[i], &errorCode);
         if(U_FAILURE(errorCode)) {
             log_data_err("unable to open %s converter - %s\n", converterNames[i], u_errorName(errorCode));
             continue;
         }
         if(!getTestChar(cnv, converterNames[i], charUTF8, &charUTF8Length, char0, &char0Length, char1, &char1Length)) {
             continue;
         }
         testFromTruncatedUTF8(utf8Cnv, cnv, converterNames[i], charUTF8, charUTF8Length, char0, char0Length, char1, char1Length);
@@ skipping 38 matching lines @@
     UChar pivotBuffer[128];
     UChar *pivotSource, *pivotTarget;
 
     errorCode=U_ZERO_ERROR;
     utf8Cnv=ucnv_open("UTF-8", &errorCode);
     if(U_FAILURE(errorCode)) {
         log_data_err("unable to open UTF-8 converter - %s\n", u_errorName(errorCode));
         return;
     }
 
-    for(i=0; i<LENGTHOF(converterNames); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(converterNames); ++i) {
         errorCode=U_ZERO_ERROR;
         cnv=ucnv_open(converterNames[i], &errorCode);
         ucnv_setFromUCallBack(cnv, UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_XML_DEC,
                               NULL, NULL, &errorCode);
         if(U_FAILURE(errorCode)) {
             log_data_err("unable to open %s converter - %s\n",
                          converterNames[i], u_errorName(errorCode));
             continue;
         }
         src=bad_utf8;
         target=dest;
         uprv_memset(dest, 9, sizeof(dest));
-        if(i==LENGTHOF(converterNames)-1) {
+        if(i==UPRV_LENGTHOF(converterNames)-1) {
             /* conversion to UTF-8 yields two U+FFFD directly */
             expected=twoFFFD;
             expectedLength=6;
         } else {
             /* conversion to a non-Unicode charset yields two NCRs */
             expected=twoNCRs;
             expectedLength=16;
         }
         pivotBuffer[0]=0;
         pivotBuffer[1]=1;
         pivotBuffer[2]=2;
         pivotSource=pivotTarget=pivotBuffer;
         ucnv_convertEx(
             cnv, utf8Cnv,
             &target, dest+expectedLength,
             &src, bad_utf8+sizeof(bad_utf8),
-            pivotBuffer, &pivotSource, &pivotTarget, pivotBuffer+LENGTHOF(pivotBuffer),
+            pivotBuffer, &pivotSource, &pivotTarget, pivotBuffer+UPRV_LENGTHOF(pivotBuffer),
             TRUE, TRUE, &errorCode);
         if( errorCode!=U_STRING_NOT_TERMINATED_WARNING || src!=bad_utf8+2 ||
             target!=dest+expectedLength || 0!=uprv_memcmp(dest, expected, expectedLength) ||
             dest[expectedLength]!=9
         ) {
             log_err("ucnv_convertEx(UTF-8 C5 F0 -> %s/decimal NCRs) failed\n", converterNames[i]);
         }
         ucnv_close(cnv);
     }
     ucnv_close(utf8Cnv);
@@ skipping 170 matching lines @@
         { 3, "LMBCS-6"},
         { 3, "LMBCS-8"},
         { 3, "LMBCS-11"},
         { 3, "LMBCS-16"},
         { 3, "LMBCS-17"},
         { 3, "LMBCS-18"},
         { 3, "LMBCS-19"}
     };
     int32_t idx;
 
-    for (idx = 0; idx < LENGTHOF(converter); idx++) {
+    for (idx = 0; idx < UPRV_LENGTHOF(converter); idx++) {
         UErrorCode status = U_ZERO_ERROR;
         UConverter *cnv = cnv_open(converter[idx].name, &status);
         if (U_FAILURE(status)) {
             continue;
         }
         if (converter[idx].maxSize != ucnv_getMaxCharSize(cnv)) {
             log_err("error: ucnv_getMaxCharSize(%s) expected %d, got %d\n",
                 converter[idx].name, converter[idx].maxSize, ucnv_getMaxCharSize(cnv));
         }
         ucnv_close(cnv);
@@ skipping 141 matching lines @@
 
     pc=strstr(swappedName, UCNV_SWAP_LFNL_OPTION_STRING);
     if(swap != (pc!=NULL)) {
         log_err("TestEBCDICSwapLFNL error: ucnv_getName(%s,swaplfnl)=%s should (%d) contain 'swaplfnl'\n", name, swappedName, swap);
         goto cleanup;
     }
 
     /* convert to EBCDIC */
     pcu=text;
     pc=normal;
-    ucnv_fromUnicode(cnv, &pc, normal+LENGTHOF(normal), &pcu, text+LENGTHOF(text), NULL, TRUE, &errorCode);
+    ucnv_fromUnicode(cnv, &pc, normal+UPRV_LENGTHOF(normal), &pcu, text+UPRV_LENGTHOF(text), NULL, TRUE, &errorCode);
     normalLength=(int32_t)(pc-normal);
 
     pcu=text;
     pc=swapped;
-    ucnv_fromUnicode(swapCnv, &pc, swapped+LENGTHOF(swapped), &pcu, text+LENGTHOF(text), NULL, TRUE, &errorCode);
+    ucnv_fromUnicode(swapCnv, &pc, swapped+UPRV_LENGTHOF(swapped), &pcu, text+UPRV_LENGTHOF(text), NULL, TRUE, &errorCode);
     swappedLength=(int32_t)(pc-swapped);
 
     if(U_FAILURE(errorCode)) {
         log_err("TestEBCDICSwapLFNL error converting to %s - (%s)\n", name, u_errorName(errorCode));
         goto cleanup;
     }
 
     /* compare EBCDIC output */
     if(normalLength!=swappedLength) {
         log_err("TestEBCDICSwapLFNL error converting to %s - output lengths %d vs. %d\n", name, normalLength, swappedLength);
@@ skipping 12 matching lines @@
 
         if(c!=swapped[i]) {
             log_err("TestEBCDICSwapLFNL error converting to %s - did not swap properly, output[%d]=0x%02x\n", name, i, (uint8_t)swapped[i]);
             goto cleanup;
         }
     }
 
     /* convert back to Unicode (may not roundtrip) */
     pc=normal;
     pu=uNormal;
-    ucnv_toUnicode(cnv, &pu, uNormal+LENGTHOF(uNormal), (const char **)&pc, normal+normalLength, NULL, TRUE, &errorCode);
+    ucnv_toUnicode(cnv, &pu, uNormal+UPRV_LENGTHOF(uNormal), (const char **)&pc, normal+normalLength, NULL, TRUE, &errorCode);
     normalLength=(int32_t)(pu-uNormal);
 
     pc=normal;
     pu=uSwapped;
-    ucnv_toUnicode(swapCnv, &pu, uSwapped+LENGTHOF(uSwapped), (const char **)&pc, normal+swappedLength, NULL, TRUE, &errorCode);
+    ucnv_toUnicode(swapCnv, &pu, uSwapped+UPRV_LENGTHOF(uSwapped), (const char **)&pc, normal+swappedLength, NULL, TRUE, &errorCode);
     swappedLength=(int32_t)(pu-uSwapped);
 
     if(U_FAILURE(errorCode)) {
         log_err("TestEBCDICSwapLFNL error converting from %s - (%s)\n", name, u_errorName(errorCode));
         goto cleanup;
     }
 
     /* compare EBCDIC output */
     if(normalLength!=swappedLength) {
         log_err("TestEBCDICSwapLFNL error converting from %s - output lengths %d vs. %d\n", name, normalLength, swappedLength);
@@ skipping 30 matching lines @@
     } tests[]={
         { "ibm-37", TRUE },
         { "ibm-1047", TRUE },
         { "ibm-1140", TRUE },
         { "ibm-930", TRUE },
         { "iso-8859-3", FALSE }
     };
 
     int i;
 
-    for(i=0; i<LENGTHOF(tests); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(tests); ++i) {
         testSwap(tests[i].name, tests[i].swap);
     }
 }
 #else
 static void
 TestEBCDICSwapLFNL() {
   /* test nothing... */
 }
 #endif
 
-static const UVersionInfo ICU_34 = {3,4,0,0};
-
 static void TestFromUCountPending(){
 #if !UCONFIG_NO_LEGACY_CONVERSION
     UErrorCode status = U_ZERO_ERROR;
 /*       const UChar expectedUnicode[] = { 0x20ac, 0x0005, 0x0006, 0x000b, 0xdbc4, 0xde34, 0xd84d, 0xdc56, 0xfffd}; */
     static const struct {
         UChar input[6];
         int32_t len;
         int32_t exp;
     }fromUnicodeTests[] = {
         /*m:n conversion*/
         {{0xdbc4},1,1},
         {{ 0xdbc4, 0xde34, 0xd84d},3,1},
         {{ 0xdbc4, 0xde34, 0xd900},3,3},
     };
     int i;
     UConverter* cnv = ucnv_openPackage(loadTestData(&status), "test3", &status);
     if(U_FAILURE(status)){
         log_data_err("Could not create converter for test3. Error: %s\n", u_errorName(status));
         return;
     }
-    for(i=0; i<LENGTHOF(fromUnicodeTests); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(fromUnicodeTests); ++i) {
         char tgt[10];
         char* target = tgt;
         char* targetLimit = target + 10;
         const UChar* source = fromUnicodeTests[i].input;
         const UChar* sourceLimit = source + fromUnicodeTests[i].len; 
         int32_t len = 0;
         ucnv_reset(cnv);
         ucnv_fromUnicode(cnv,&target, targetLimit, &source, sourceLimit, NULL, FALSE, &status);
         len = ucnv_fromUCountPending(cnv, &status);
         if(U_FAILURE(status)){
@@ skipping 85 matching lines @@
     };
 
     int i;
     UConverterToUCallback *oldToUAction= NULL;
     UConverter* cnv = ucnv_openPackage(loadTestData(&status), "test3", &status);
     if(U_FAILURE(status)){
         log_data_err("Could not create converter for test3. Error: %s\n", u_errorName(status));
         return;
     }
     ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_STOP, NULL, oldToUAction, NULL, &status);
-    for(i=0; i<LENGTHOF(toUnicodeTests); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(toUnicodeTests); ++i) {
         UChar tgt[20];
         UChar* target = tgt;
         UChar* targetLimit = target + 20;
         const char* source = toUnicodeTests[i].input;
         const char* sourceLimit = source + toUnicodeTests[i].len; 
         int32_t len = 0;
         ucnv_reset(cnv);
         ucnv_toUnicode(cnv, &target, targetLimit, &source, sourceLimit, NULL, FALSE, &status);
         len = ucnv_toUCountPending(cnv,&status);
         if(U_FAILURE(status)){
@@ skipping 217 matching lines @@
         log_err("ucnv_fromUChars(UTF-32, U+D900) did not write a BOM\n");
     }
 
     /* Simple API test of ucnv_setSubstString() + ucnv_getSubstChars(). */
     errorCode=U_ZERO_ERROR;
     cnv=ucnv_open("ISO-8859-1", &errorCode);
     if(U_FAILURE(errorCode)) {
         log_data_err("ucnv_open(ISO-8859-1) failed - %s\n", u_errorName(errorCode));
         return;
     }
-    ucnv_setSubstString(cnv, sub, LENGTHOF(sub), &errorCode);
+    ucnv_setSubstString(cnv, sub, UPRV_LENGTHOF(sub), &errorCode);
     if(U_FAILURE(errorCode)) {
         log_err("ucnv_setSubstString(ISO-8859-1, sub[5]) failed - %s\n", u_errorName(errorCode));
     } else {
         len8 = sizeof(buffer);
         ucnv_getSubstChars(cnv, buffer, &len8, &errorCode);
         /* Stateless converter, we expect the string converted to charset bytes. */
         if(U_FAILURE(errorCode) || len8!=sizeof(subChars) || 0!=uprv_memcmp(buffer, subChars, len8)) {
             log_err("ucnv_getSubstChars(ucnv_setSubstString(ISO-8859-1, sub[5])) failed - %s\n", u_errorName(errorCode));
         }
     }
     ucnv_close(cnv);
 
 #if !UCONFIG_NO_LEGACY_CONVERSION
     errorCode=U_ZERO_ERROR;
     cnv=ucnv_open("HZ", &errorCode);
     if(U_FAILURE(errorCode)) {
         log_data_err("ucnv_open(HZ) failed - %s\n", u_errorName(errorCode));
         return;
     }
-    ucnv_setSubstString(cnv, sub, LENGTHOF(sub), &errorCode);
+    ucnv_setSubstString(cnv, sub, UPRV_LENGTHOF(sub), &errorCode);
     if(U_FAILURE(errorCode)) {
         log_err("ucnv_setSubstString(HZ, sub[5]) failed - %s\n", u_errorName(errorCode));
     } else {
         len8 = sizeof(buffer);
         ucnv_getSubstChars(cnv, buffer, &len8, &errorCode);
         /* Stateful converter, we expect that the Unicode string was set and that we get an empty char * string now. */
         if(U_FAILURE(errorCode) || len8!=0) {
             log_err("ucnv_getSubstChars(ucnv_setSubstString(HZ, sub[5])) failed - %s\n", u_errorName(errorCode));
         }
     }
@@ skipping 64 matching lines @@
 static void TestGetName() {
     static const char *const names[] = {
         "Unicode",                  "UTF-16",
         "UnicodeBigUnmarked",       "UTF-16BE",
         "UnicodeBig",               "UTF-16BE,version=1",
         "UnicodeLittleUnmarked",    "UTF-16LE",
         "UnicodeLittle",            "UTF-16LE,version=1",
         "x-UTF-16LE-BOM",           "UTF-16LE,version=1"
     };
     int32_t i;
-    for(i = 0; i < LENGTHOF(names); i += 2) {
+    for(i = 0; i < UPRV_LENGTHOF(names); i += 2) {
         UErrorCode errorCode = U_ZERO_ERROR;
         UConverter *cnv = ucnv_open(names[i], &errorCode);
         if(U_SUCCESS(errorCode)) {
             const char *name = ucnv_getName(cnv, &errorCode);
             if(U_FAILURE(errorCode) || 0 != strcmp(name, names[i+1])) {
                 log_err("ucnv_getName(%s) = %s != %s -- %s\n",
                         names[i], name, names[i+1], u_errorName(errorCode));
             }
             ucnv_close(cnv);
         }
@@ skipping 22 matching lines @@
         { 2, 0, 0x61 },
         { 4, 0xfe, 0xff, 0, 0x61 },
 
         { 2, 0x61, 0 },
         { 4, 0xff, 0xfe, 0x61, 0 }
     };
 
     char bytes[10];
     int32_t i;
 
-    for(i = 0; i < LENGTHOF(names); ++i) {
+    for(i = 0; i < UPRV_LENGTHOF(names); ++i) {
         UErrorCode errorCode = U_ZERO_ERROR;
         UConverter *cnv = ucnv_open(names[i], &errorCode);
         int32_t length = 0;
         const uint8_t *exp = expected[i];
         if (U_FAILURE(errorCode)) {
            log_err_status(errorCode, "Unable to open converter: %s got error code: %s\n", names[i], u_errorName(errorCode));
            continue;
         }
         length = ucnv_fromUChars(cnv, bytes, (int32_t)sizeof(bytes), a16, 1, &errorCode);
         
         if(U_FAILURE(errorCode) || length != exp[0] || 0 != memcmp(bytes, exp+1, length)) {
             log_err("unexpected %s BOM writing behavior -- %s\n",
                     names[i], u_errorName(errorCode));
         }
         ucnv_close(cnv);
     }
 }