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