icuSources/test/cintltst/stdnmtst.c

   1 /********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 2000-2016, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ********************************************************************/
   6 /*
   7 * File stdnmtst.c
   8 *
   9 * Modification History:
  10 *
  11 *   Date          Name        Description
  12 *   08/05/2000    Yves       Creation
  13 ******************************************************************************
  14 */
  15
  16 #include "unicode/ucnv.h"
  17 #include "unicode/ustring.h"
  18 #include "cmemory.h"
  19 #include "cstring.h"
  20 #include "cintltst.h"
  21
  22 static void TestStandardName(void);
  23 static void TestStandardNames(void);
  24 static void TestCanonicalName(void);
  25
  26 void addStandardNamesTest(TestNode** root);
  27
  28
  29 void
  30 addStandardNamesTest(TestNode** root)
  31 {
  32   addTest(root, &TestStandardName,  "tsconv/stdnmtst/TestStandardName");
  33   addTest(root, &TestStandardNames, "tsconv/stdnmtst/TestStandardNames");
  34   addTest(root, &TestCanonicalName, "tsconv/stdnmtst/TestCanonicalName");
  35 }
  36
  37 static int dotestname(const char *name, const char *standard, const char *expected) {
  38     int res = 1;
  39
  40     UErrorCode error;
  41     const char *tag;
  42
  43     error = U_ZERO_ERROR;
  44     tag = ucnv_getStandardName(name, standard, &error);
  45     if (!tag && expected) {
  46         log_err_status(error, "FAIL: could not find %s standard name for %s\n", standard, name);
  47         res = 0;
  48     } else if (expected && (name == tag || uprv_strcmp(expected, tag))) {
  49         log_err("FAIL: expected %s for %s standard name for %s, got %s\n", expected, standard, name, tag);
  50         res = 0;
  51     }
  52
  53     return res;
  54 }
  55
  56 static void TestStandardName()
  57 {
  58     int res = 1;
  59
  60     uint16_t i, count;
  61     UErrorCode err;
  62
  63     /* Iterate over all standards. */
  64     for (i = 0, count = ucnv_countStandards(); i < count-1; ++i) {
  65         const char *standard;
  66
  67         err = U_ZERO_ERROR;
  68         standard = ucnv_getStandard(i, &err);
  69         if (U_FAILURE(err)) {
  70             log_err("FAIL: ucnv_getStandard(%d), error=%s\n", i, u_errorName(err));
  71             res = 0;
  72         } else if (!standard || !*standard) {
  73             log_err("FAIL: %s standard name at index %d\n", (standard ? "empty" :
  74                 "null"), i);
  75             res = 0;
  76         }
  77     }
  78     err = U_ZERO_ERROR;
  79     /* "" must be last */
  80     if(!count) {
  81       log_data_err("No standards. You probably have no data.\n");
  82     } else if (*ucnv_getStandard((uint16_t)(count-1), &err) != 0) {
  83         log_err("FAIL: ucnv_getStandard(%d) should return ""\n", count-1);
  84         res = 0;
  85     }
  86     err = U_ZERO_ERROR;
  87     if (ucnv_getStandard(++i, &err)) {
  88         log_err("FAIL: ucnv_getStandard(%d) should return NULL\n", i);
  89         res = 0;
  90     }
  91
  92     if (res) {
  93         log_verbose("PASS: iterating over standard names works\n");
  94     }
  95
  96     /* Test for some expected results. */
  97
  98     if (dotestname("ibm-1208", "MIME", "UTF-8") &&
  99         /*dotestname("cp1252", "MIME", "windows-1252") &&*/
 100         dotestname("ascii", "MIME", "US-ASCII") &&
 101         dotestname("csiso2022jp2", "MIME", "ISO-2022-JP-2") &&
 102         dotestname("Iso20-22__cN", "IANA", "ISO-2022-CN") &&
 103         dotestname("ascii", "IANA", "ANSI_X3.4-1968") &&
 104         dotestname("cp850", "IANA", "IBM850") &&
 105         dotestname("crazy", "MIME", NULL) &&
 106         dotestname("ASCII", "crazy", NULL) &&
 107         dotestname("LMBCS-1", "MIME", NULL))
 108     {
 109         log_verbose("PASS: getting IANA and MIME standard names works\n");
 110     }
 111 }
 112
 113 static int dotestconv(const char *name, const char *standard, const char *expected) {
 114     int res = 1;
 115
 116     UErrorCode error;
 117     const char *tag;
 118
 119     error = U_ZERO_ERROR;
 120     tag = ucnv_getCanonicalName(name, standard, &error);
 121     if (tag && !expected) {
 122         log_err("FAIL: Unexpectedly found %s canonical name for %s, got %s\n", standard, name, tag);
 123         res = 0;
 124     }
 125     else if (!tag && expected) {
 126         log_err_status(error, "FAIL: could not find %s canonical name for %s\n", (standard ? "\"\"" : standard), name);
 127         res = 0;
 128     }
 129     else if (expected && (name == tag || uprv_strcmp(expected, tag) != 0)) {
 130         log_err("FAIL: expected %s for %s canonical name for %s, got %s\n", expected, standard, name, tag);
 131         res = 0;
 132     }
 133     else {
 134         log_verbose("PASS: (\"%s\", \"%s\") -> %s == %s \n", name, standard, tag, expected);
 135     }
 136
 137     return res;
 138 }
 139
 140 static void TestCanonicalName()
 141 {
 142     /* Test for some expected results. */
 143
 144     if (dotestconv("UTF-8", "IANA", "UTF-8") &&     /* default name */
 145         dotestconv("UTF-8", "MIME", "UTF-8") &&     /* default name */
 146         dotestconv("ibm-1208", "IBM", "UTF-8") &&   /* default name */
 147         dotestconv("ibm-5305", "IBM", "UTF-8") &&   /* non-default name */
 148         dotestconv("ibm-5305", "MIME", NULL) &&     /* mapping does not exist */
 149         dotestconv("ascii", "MIME", NULL) &&        /* mapping does not exist */
 150         dotestconv("ibm-1208", "IANA", NULL) &&     /* mapping does not exist */
 151         dotestconv("ibm-5305", "IANA", NULL) &&     /* mapping does not exist */
 152         dotestconv("cp1208", "", "UTF-8") &&        /* default name due to ordering */
 153         dotestconv("UTF16_BigEndian", "", "UTF-16BE") &&        /* non-default name due to ordering */
 154         dotestconv("ISO-2022-CN", "IANA", "ISO_2022,locale=zh,version=0") &&/* default name */
 155         dotestconv("Shift_JIS", "MIME", "ibm-943_P15A-2003") &&/* ambiguous alias */
 156         dotestconv("Shift_JIS", "", "ibm-943_P130-1999") &&/* ambiguous alias */
 157         dotestconv("ibm-943", "", "ibm-943_P15A-2003") &&/* ambiguous alias */
 158         dotestconv("ibm-943", "IBM", "ibm-943_P130-1999") &&/* ambiguous alias */
 159         dotestconv("ibm-1363", "", "ibm-1363_P11B-1998") &&/* ambiguous alias */
 160         dotestconv("ibm-1363", "IBM", "ibm-1363_P110-1997") &&/* ambiguous alias */
 161         dotestconv("crazy", "MIME", NULL) &&
 162         dotestconv("ASCII", "crazy", NULL))
 163     {
 164         log_verbose("PASS: getting IANA and MIME canonical names works\n");
 165     }
 166 }
 167
 168
 169 static UBool doTestNames(const char *name, const char *standard, const char **expected, int32_t size) {
 170     UErrorCode err = U_ZERO_ERROR;
 171     UEnumeration *myEnum = ucnv_openStandardNames(name, standard, &err);
 172     const char *enumName, *testName;
 173     int32_t enumCount = uenum_count(myEnum, &err);
 174     int32_t idx, len, repeatTimes = 3;
 175
 176     if (err == U_FILE_ACCESS_ERROR) {
 177         log_data_err("Unable to open standard names for %s of standard: %s\n", name, standard);
 178         return 0;
 179     }
 180     if (size != enumCount) {
 181         log_err("FAIL: different size arrays for %s. Got %d. Expected %d\n", name, enumCount, size);
 182         return 0;
 183     }
 184     if (size < 0 && myEnum) {
 185         log_err("FAIL: size < 0, but recieved an actual object\n");
 186         return 0;
 187     }
 188     log_verbose("\n%s %s\n", name, standard);
 189     while (repeatTimes-- > 0) {
 190         for (idx = 0; idx < enumCount; idx++) {
 191             enumName = uenum_next(myEnum, &len, &err);
 192             testName = expected[idx];
 193             if (uprv_strcmp(enumName, testName) != 0 || U_FAILURE(err)
 194                 || len != (int32_t)uprv_strlen(expected[idx]))
 195             {
 196                 log_err("FAIL: uenum_next(%d) == \"%s\". expected \"%s\", len=%d, error=%s\n",
 197                     idx, enumName, testName, len, u_errorName(err));
 198             }
 199             log_verbose("%s\n", enumName);
 200             err = U_ZERO_ERROR;
 201         }
 202         if (enumCount >= 0) {
 203             /* one past the list of all names must return NULL */
 204             enumName = uenum_next(myEnum, &len, &err);
 205             if (enumName != NULL || len != 0 || U_FAILURE(err)) {
 206                 log_err("FAIL: uenum_next(past the list) did not return NULL[0] with U_SUCCESS(). name=%s standard=%s len=%d err=%s\n", name, standard, len, u_errorName(err));
 207             }
 208         }
 209         log_verbose("\n    reset\n");
 210         uenum_reset(myEnum, &err);
 211         if (U_FAILURE(err)) {
 212             log_err("FAIL: uenum_reset() for %s{%s} failed with %s\n",
 213                 name, standard, u_errorName(err));
 214             err = U_ZERO_ERROR;
 215         }
 216     }
 217     uenum_close(myEnum);
 218     return 1;
 219 }
 220
 221 static UBool doTestUCharNames(const char *name, const char *standard, const char **expected, int32_t size) {
 222     UErrorCode err = U_ZERO_ERROR;
 223     UEnumeration *myEnum = ucnv_openStandardNames(name, standard, &err);
 224     int32_t enumCount = uenum_count(myEnum, &err);
 225     int32_t idx, repeatTimes = 3;
 226
 227     if (err == U_FILE_ACCESS_ERROR) {
 228         log_data_err("Unable to open standard names for %s of standard: %s\n", name, standard);
 229         return 0;
 230     }
 231
 232     if (size != enumCount) {
 233         log_err("FAIL: different size arrays. Got %d. Expected %d\n", enumCount, size);
 234         return 0;
 235     }
 236     if (size < 0 && myEnum) {
 237         log_err("FAIL: size < 0, but recieved an actual object\n");
 238         return 0;
 239     }
 240     log_verbose("\n%s %s\n", name, standard);
 241     while (repeatTimes-- > 0) {
 242         for (idx = 0; idx < enumCount; idx++) {
 243             UChar testName[256];
 244             int32_t len;
 245             const UChar *enumName = uenum_unext(myEnum, &len, &err);
 246             u_uastrncpy(testName, expected[idx], UPRV_LENGTHOF(testName));
 247             if (u_strcmp(enumName, testName) != 0 || U_FAILURE(err)
 248                 || len != (int32_t)uprv_strlen(expected[idx]))
 249             {
 250                 log_err("FAIL: uenum_next(%d) == \"%s\". expected \"%s\", len=%d, error=%s\n",
 251                     idx, enumName, testName, len, u_errorName(err));
 252             }
 253             log_verbose("%s\n", expected[idx]);
 254             err = U_ZERO_ERROR;
 255         }
 256         log_verbose("\n    reset\n");
 257         uenum_reset(myEnum, &err);
 258         if (U_FAILURE(err)) {
 259             log_err("FAIL: uenum_reset() for %s{%s} failed with %s\n",
 260                 name, standard, u_errorName(err));
 261             err = U_ZERO_ERROR;
 262         }
 263     }
 264     uenum_close(myEnum);
 265     return 1;
 266 }
 267
 268 static void TestStandardNames()
 269 {
 270     static const char *asciiIANA[] = {
 271         "ANSI_X3.4-1968",
 272         "US-ASCII",
 273         "ASCII",
 274         "ANSI_X3.4-1986",
 275         "ISO_646.irv:1991",
 276         "ISO646-US",
 277         "us",
 278         "csASCII",
 279         "iso-ir-6",
 280         "cp367",
 281         "IBM367",
 282     };
 283     static const char *asciiMIME[] = {
 284         "US-ASCII"
 285     };
 286
 287     static const char *iso2022MIME[] = {
 288         "ISO-2022-KR",
 289     };
 290
 291     doTestNames("ASCII", "IANA", asciiIANA, UPRV_LENGTHOF(asciiIANA));
 292     doTestNames("US-ASCII", "IANA", asciiIANA, UPRV_LENGTHOF(asciiIANA));
 293     doTestNames("ASCII", "MIME", asciiMIME, UPRV_LENGTHOF(asciiMIME));
 294     doTestNames("ascii", "mime", asciiMIME, UPRV_LENGTHOF(asciiMIME));
 295
 296     doTestNames("ASCII", "crazy", asciiMIME, -1);
 297     doTestNames("crazy", "MIME", asciiMIME, -1);
 298
 299     doTestNames("LMBCS-1", "MIME", asciiMIME, 0);
 300
 301     doTestNames("ISO_2022,locale=ko,version=0", "MIME", iso2022MIME, UPRV_LENGTHOF(iso2022MIME));
 302     doTestNames("csiso2022kr", "MIME", iso2022MIME, UPRV_LENGTHOF(iso2022MIME));
 303
 304     log_verbose(" Testing unext()\n");
 305     doTestUCharNames("ASCII", "IANA", asciiIANA, UPRV_LENGTHOF(asciiIANA));
 306
 307 }