ICU 56 update step 1

source/test/cintltst/ccapitst.c

 /********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 1997-2014, International Business Machines Corporation and
+ * Copyright (c) 1997-2015, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /*****************************************************************************
 *
-* File CU_CAPITST.C
+* File ccapitst.c
 *
 * Modification History:
 *        Name                      Description            
 *     Madhu Katragadda              Ported for C API
 ******************************************************************************
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
@@ skipping 1123 matching lines @@
  */
 static void TestAlias() {
     int32_t i, ncnv;
     UErrorCode status = U_ZERO_ERROR;
 
     /* Predetermined aliases that we expect to map back to ISO_2022
      * and UTF-8.  UPDATE THIS DATA AS NECESSARY. */
     const char* ISO_2022_NAMES[] = 
         {"ISO_2022,locale=ja,version=2", "ISO-2022-JP-2", "csISO2022JP2",
          "Iso-2022jP2", "isO-2022_Jp_2", "iSo--2022,locale=ja,version=2"};
-    int32_t ISO_2022_NAMES_LENGTH =
-        sizeof(ISO_2022_NAMES) / sizeof(ISO_2022_NAMES[0]);
+    int32_t ISO_2022_NAMES_LENGTH = UPRV_LENGTHOF(ISO_2022_NAMES);
     const char *UTF8_NAMES[] =
         { "UTF-8", "utf-8", "utf8", "ibm-1208",
           "utf_8", "ibm1208", "cp1208" };
-    int32_t UTF8_NAMES_LENGTH =
-        sizeof(UTF8_NAMES) / sizeof(UTF8_NAMES[0]);
+    int32_t UTF8_NAMES_LENGTH = UPRV_LENGTHOF(UTF8_NAMES);
 
     struct {
         const char *name;
         const char *alias;
     } CONVERTERS_NAMES[] = {
         { "UTF-32BE", "UTF32_BigEndian" },
         { "UTF-32LE", "UTF32_LittleEndian" },
         { "UTF-32",   "ISO-10646-UCS-4" },
         { "UTF32_PlatformEndian", "UTF32_PlatformEndian" },
         { "UTF-32",   "ucs-4" }
@@ skipping 20 matching lines @@
         cnv = ucnv_open(name, &status);
         if (U_FAILURE(status)) {
             log_data_err("FAIL: Converter \"%s\" (i=%d)"
                     " can't be opened.\n",
                     name, i);
         }
         else {
             if (strcmp(ucnv_getName(cnv, &status), name) != 0 
                 && (strstr(name, "PlatformEndian") == 0 && strstr(name, "OppositeEndian") == 0)) {
                 log_err("FAIL: Converter \"%s\" returned \"%s\" for getName. "
-                        "The should be the same\n",
+                        "They should be the same\n",
                         name, ucnv_getName(cnv, &status));
             }
         }
         ucnv_close(cnv);
 
         status = U_ZERO_ERROR;
         alias0 = ucnv_getAlias(name, 0, &status);
         for (j=1; j<na; ++j) {
             const char *alias;
             /* Make sure each alias maps back to the the same list of
@@ skipping 785 matching lines @@
       }
    }
 #endif
 }
 
 /* bug2: pre-flighting loop bug: simple overflow causes bug */
 static void bug2()
 {
     /* US-ASCII "1234567890" */
     static const char source[]={ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39 };
+#if !UCONFIG_ONLY_HTML_CONVERSION
     static const char sourceUTF8[]={ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, (char)0xef, (char)0x80, (char)0x80 };
     static const char sourceUTF32[]={ 0x00, 0x00, 0x00, 0x30,
                                       0x00, 0x00, 0x00, 0x31,
                                       0x00, 0x00, 0x00, 0x32,
                                       0x00, 0x00, 0x00, 0x33,
                                       0x00, 0x00, 0x00, 0x34,
                                       0x00, 0x00, 0x00, 0x35,
                                       0x00, 0x00, 0x00, 0x36,
                                       0x00, 0x00, 0x00, 0x37,
                                       0x00, 0x00, 0x00, 0x38,
                                       0x00, 0x00, (char)0xf0, 0x00};
+#endif
+
     static char target[5];
 
     UErrorCode err = U_ZERO_ERROR;
     int32_t size;
 
     /* do the conversion */
     size = ucnv_convert("iso-8859-1", /* out */
                         "us-ascii",  /* in */
                         target,
                         sizeof(target),
                         source,
                         sizeof(source),
                         &err);
 
     if ( size != 10 ) {
         /* bug2: size is 5, should be 10 */
         log_data_err("error j932 bug 2 us-ascii->iso-8859-1: got preflighting size %d instead of 10\n", size);
     }
 
+#if !UCONFIG_ONLY_HTML_CONVERSION
     err = U_ZERO_ERROR;
     /* do the conversion */
     size = ucnv_convert("UTF-32BE", /* out */
                         "UTF-8",  /* in */
                         target,
                         sizeof(target),
                         sourceUTF8,
                         sizeof(sourceUTF8),
                         &err);
 
     if ( size != 32 ) {
         /* bug2: size is 5, should be 32 */
         log_err("error j932 bug 2 UTF-8->UTF-32BE: got preflighting size %d instead of 32\n", size);
     }
 
     err = U_ZERO_ERROR;
     /* do the conversion */
     size = ucnv_convert("UTF-8", /* out */
                         "UTF-32BE",  /* in */
                         target,
                         sizeof(target),
                         sourceUTF32,
                         sizeof(sourceUTF32),
                         &err);
 
     if ( size != 12 ) {
         /* bug2: size is 5, should be 12 */
         log_err("error j932 bug 2 UTF-32BE->UTF-8: got preflighting size %d instead of 12\n", size);
     }
+#endif
 }
 
 /*
  * bug3: when the characters expand going from source to target codepage
  *       you get bug3 in addition to bug2
  */
 static void bug3()
 {
-#if !UCONFIG_NO_LEGACY_CONVERSION
+#if !UCONFIG_NO_LEGACY_CONVERSION && !UCONFIG_ONLY_HTML_CONVERSION
     char char_in[CHUNK_SIZE*4];
     char target[5];
     UErrorCode err = U_ZERO_ERROR;
     int32_t size;
 
     /*
      * first get the buggy size from bug2 then
      * compare it to buggy size with an expansion
      */
     memset(char_in, 0x61, sizeof(char_in)); /* US-ASCII 'a' */
@@ skipping 663 matching lines @@
     },
   /*errorTarget[]={*/
         /*
          * expected output when converting shiftJIS[] from UTF-8 to Shift-JIS:
          * SUB, SUB, 0x40, SUB, SUB, 0x40
          */
   /* 0x81, 0xa1, 0x81, 0xa1, 0x40, 0x81, 0xa1, 0x81, 0xa1, 0x40*/
   /*},*/
     utf16[]={
         0xfe, 0xff /* BOM only, no text */
-    },
-    utf32[]={
+    };
+#if !UCONFIG_ONLY_HTML_CONVERSION
+    static const uint8_t utf32[]={
         0xff, 0xfe, 0, 0 /* BOM only, no text */
     };
+#endif
 
     char target[100], utf8NUL[100], shiftJISNUL[100];
 
     UConverter *cnv;
     UErrorCode errorCode;
 
     int32_t length;
 
     errorCode=U_ZERO_ERROR;
     cnv=ucnv_open("Shift-JIS", &errorCode);
@@ skipping 49 matching lines @@
     /* pseudo-empty string, no target buffer */
     errorCode=U_ZERO_ERROR;
     length=ucnv_fromAlgorithmic(cnv, UCNV_UTF16, target, 0, (const char *)utf16, 2, &errorCode);
     if( errorCode!=U_STRING_NOT_TERMINATED_WARNING ||
         length!=0
     ) {
         log_err("ucnv_fromAlgorithmic(UTF-16 only BOM -> Shift-JIS) fails (%s expect U_STRING_NOT_TERMINATED_WARNING), returns %d expect 0\n",
                 u_errorName(errorCode), length);
     }
 
+#if !UCONFIG_ONLY_HTML_CONVERSION
     errorCode=U_ZERO_ERROR;
     length=ucnv_fromAlgorithmic(cnv, UCNV_UTF32, target, 0, (const char *)utf32, 4, &errorCode);
     if( errorCode!=U_STRING_NOT_TERMINATED_WARNING ||
         length!=0
     ) {
         log_err("ucnv_fromAlgorithmic(UTF-32 only BOM -> Shift-JIS) fails (%s expect U_STRING_NOT_TERMINATED_WARNING), returns %d expect 0\n",
                 u_errorName(errorCode), length);
     }
+#endif
 
     /* bad arguments */
     errorCode=U_MESSAGE_PARSE_ERROR;
     length=ucnv_fromAlgorithmic(cnv, UCNV_UTF16, target, 0, (const char *)utf16, 2, &errorCode);
     if(errorCode!=U_MESSAGE_PARSE_ERROR) {
         log_err("ucnv_fromAlgorithmic(U_MESSAGE_PARSE_ERROR) sets %s\n", u_errorName(errorCode));
     }
 
     /* source==NULL */
     errorCode=U_ZERO_ERROR;
@@ skipping 574 matching lines @@
 
     log_verbose("getDefaultName returned %s\n", defaultName);
 
     /*change the default name by setting it */
     TestOneDefaultNameChange("UTF-8", "UTF-8");
 #if U_CHARSET_IS_UTF8
     TestOneDefaultNameChange("ISCII,version=1", "UTF-8");
     TestOneDefaultNameChange("ISCII,version=2", "UTF-8");
     TestOneDefaultNameChange("ISO-8859-1", "UTF-8");
 #else
-# if !UCONFIG_NO_LEGACY_CONVERSION
+# if !UCONFIG_NO_LEGACY_CONVERSION && !UCONFIG_ONLY_HTML_CONVERSION
     TestOneDefaultNameChange("ISCII,version=1", "ISCII,version=1");
     TestOneDefaultNameChange("ISCII,version=2", "ISCII,version=2");
 # endif
     TestOneDefaultNameChange("ISO-8859-1", "ISO-8859-1");
 #endif
 
     /*set the default name back*/
     ucnv_setDefaultName(defaultName);
 }
 
@@ skipping 259 matching lines @@
         }
         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);
     }
 }