icuSources/test/cintltst/stdnmtst.c

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