| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ******************************************************************************* | |
| 3 * | |
| 4 * Copyright (C) 2003-2014, International Business Machines | |
| 5 * Corporation and others. All Rights Reserved. | |
| 6 * | |
| 7 ******************************************************************************* | |
| 8 * file name: idnatest.c | |
| 9 * encoding: US-ASCII | |
| 10 * tab size: 8 (not used) | |
| 11 * indentation:4 | |
| 12 * | |
| 13 * created on: 2003jul11 | |
| 14 * created by: Ram Viswanadha | |
| 15 */ | |
| 16 #include <stdlib.h> | |
| 17 #include <string.h> | |
| 18 #include "unicode/utypes.h" | |
| 19 | |
| 20 #if !UCONFIG_NO_IDNA | |
| 21 | |
| 22 #include "unicode/ustring.h" | |
| 23 #include "unicode/uidna.h" | |
| 24 #include "cintltst.h" | |
| 25 #include "cmemory.h" | |
| 26 | |
| 27 #define MAX_DEST_SIZE 1000 | |
| 28 | |
| 29 static void TestToUnicode(void); | |
| 30 static void TestToASCII(void); | |
| 31 static void TestIDNToUnicode(void); | |
| 32 static void TestIDNToASCII(void); | |
| 33 static void TestCompare(void); | |
| 34 static void TestJB4490(void); | |
| 35 static void TestJB4475(void); | |
| 36 static void TestLength(void); | |
| 37 static void TestJB5273(void); | |
| 38 static void TestUTS46(void); | |
| 39 | |
| 40 void addIDNATest(TestNode** root); | |
| 41 | |
| 42 | |
| 43 typedef int32_t | |
| 44 (U_EXPORT2 *TestFunc) ( const UChar *src, int32_t srcLength, | |
| 45 UChar *dest, int32_t destCapacity, | |
| 46 int32_t options, UParseError *parseError, | |
| 47 UErrorCode *status); | |
| 48 typedef int32_t | |
| 49 (U_EXPORT2 *CompareFunc) (const UChar *s1, int32_t s1Len, | |
| 50 const UChar *s2, int32_t s2Len, | |
| 51 int32_t options, | |
| 52 UErrorCode *status); | |
| 53 | |
| 54 | |
| 55 void | |
| 56 addIDNATest(TestNode** root) | |
| 57 { | |
| 58 addTest(root, &TestToUnicode, "idna/TestToUnicode"); | |
| 59 addTest(root, &TestToASCII, "idna/TestToASCII"); | |
| 60 addTest(root, &TestIDNToUnicode, "idna/TestIDNToUnicode"); | |
| 61 addTest(root, &TestIDNToASCII, "idna/TestIDNToASCII"); | |
| 62 addTest(root, &TestCompare, "idna/TestCompare"); | |
| 63 addTest(root, &TestJB4490, "idna/TestJB4490"); | |
| 64 addTest(root, &TestJB4475, "idna/TestJB4475"); | |
| 65 addTest(root, &TestLength, "idna/TestLength"); | |
| 66 addTest(root, &TestJB5273, "idna/TestJB5273"); | |
| 67 addTest(root, &TestUTS46, "idna/TestUTS46"); | |
| 68 } | |
| 69 | |
| 70 static void | |
| 71 testAPI(const UChar* src, const UChar* expected, const char* testName, | |
| 72 UBool useSTD3ASCIIRules,UErrorCode expectedStatus, | |
| 73 UBool doCompare, UBool testUnassigned, TestFunc func){ | |
| 74 | |
| 75 UErrorCode status = U_ZERO_ERROR; | |
| 76 UChar destStack[MAX_DEST_SIZE]; | |
| 77 int32_t destLen = 0; | |
| 78 UChar* dest = NULL; | |
| 79 int32_t expectedLen = (expected != NULL) ? u_strlen(expected) : 0; | |
| 80 int32_t options = (useSTD3ASCIIRules == TRUE) ? UIDNA_USE_STD3_RULES : UIDNA
_DEFAULT; | |
| 81 UParseError parseError; | |
| 82 int32_t tSrcLen = 0; | |
| 83 UChar* tSrc = NULL; | |
| 84 | |
| 85 if(src != NULL){ | |
| 86 tSrcLen = u_strlen(src); | |
| 87 tSrc =(UChar*) malloc( U_SIZEOF_UCHAR * tSrcLen ); | |
| 88 memcpy(tSrc,src,tSrcLen * U_SIZEOF_UCHAR); | |
| 89 } | |
| 90 | |
| 91 /* test null-terminated source and return value of number of UChars required
*/ | |
| 92 | |
| 93 destLen = func(src,-1,NULL,0,options, &parseError , &status); | |
| 94 if(status == U_BUFFER_OVERFLOW_ERROR){ | |
| 95 status = U_ZERO_ERROR; /* reset error code */ | |
| 96 if(destLen+1 < MAX_DEST_SIZE){ | |
| 97 dest = destStack; | |
| 98 destLen = func(src,-1,dest,destLen+1,options, &parseError, &status); | |
| 99 /* TODO : compare output with expected */ | |
| 100 if(U_SUCCESS(status) && expectedStatus != U_IDNA_STD3_ASCII_RULES_ER
ROR&& (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0
,&status)!=0){ | |
| 101 log_err("Did not get the expected result for null terminated so
urce.\n" ); | |
| 102 } | |
| 103 }else{ | |
| 104 log_err( "%s null terminated source failed. Requires destCapacity >
300\n",testName); | |
| 105 } | |
| 106 } | |
| 107 | |
| 108 if(status != expectedStatus){ | |
| 109 log_err_status(status, "Did not get the expected error for %s null term
inated source failed. Expected: %s Got: %s\n",testName, u_errorName(expectedStat
us), u_errorName(status)); | |
| 110 free(tSrc); | |
| 111 return; | |
| 112 } | |
| 113 if(testUnassigned ){ | |
| 114 status = U_ZERO_ERROR; | |
| 115 destLen = func(src,-1,NULL,0,options | UIDNA_ALLOW_UNASSIGNED, &parseErr
or, &status); | |
| 116 if(status == U_BUFFER_OVERFLOW_ERROR){ | |
| 117 status = U_ZERO_ERROR; /* reset error code */ | |
| 118 if(destLen+1 < MAX_DEST_SIZE){ | |
| 119 dest = destStack; | |
| 120 destLen = func(src,-1,dest,destLen+1,options | UIDNA_ALLOW_UNASS
IGNED, &parseError, &status); | |
| 121 /* TODO : compare output with expected */ | |
| 122 if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(de
st,destLen, expected,expectedLen,0,&status)!=0){ | |
| 123 log_err("Did not get the expected result for %s null termina
ted source with both options set.\n",testName); | |
| 124 | |
| 125 } | |
| 126 }else{ | |
| 127 log_err( "%s null terminated source failed. Requires destCapacit
y > 300\n",testName); | |
| 128 } | |
| 129 } | |
| 130 /*testing query string*/ | |
| 131 if(status != expectedStatus && expectedStatus != U_IDNA_UNASSIGNED_ERROR
){ | |
| 132 log_err( "Did not get the expected error for %s null terminated sour
ce with options set. Expected: %s Got: %s\n",testName, u_errorName(expectedStatu
s), u_errorName(status)); | |
| 133 } | |
| 134 } | |
| 135 | |
| 136 status = U_ZERO_ERROR; | |
| 137 | |
| 138 /* test source with lengthand return value of number of UChars required*/ | |
| 139 destLen = func(tSrc, tSrcLen, NULL,0,options, &parseError, &status); | |
| 140 if(status == U_BUFFER_OVERFLOW_ERROR){ | |
| 141 status = U_ZERO_ERROR; /* reset error code */ | |
| 142 if(destLen+1 < MAX_DEST_SIZE){ | |
| 143 dest = destStack; | |
| 144 destLen = func(src,u_strlen(src),dest,destLen+1,options, &parseError
, &status); | |
| 145 /* TODO : compare output with expected */ | |
| 146 if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,d
estLen, expected,expectedLen,0,&status)!=0){ | |
| 147 log_err("Did not get the expected result for %s with source leng
th.\n",testName); | |
| 148 } | |
| 149 }else{ | |
| 150 log_err( "%s with source length failed. Requires destCapacity > 300
\n",testName); | |
| 151 } | |
| 152 } | |
| 153 | |
| 154 if(status != expectedStatus){ | |
| 155 log_err( "Did not get the expected error for %s with source length. Expe
cted: %s Got: %s\n",testName, u_errorName(expectedStatus), u_errorName(status)); | |
| 156 } | |
| 157 if(testUnassigned){ | |
| 158 status = U_ZERO_ERROR; | |
| 159 | |
| 160 destLen = func(tSrc,tSrcLen,NULL,0,options | UIDNA_ALLOW_UNASSIGNED, &pa
rseError, &status); | |
| 161 | |
| 162 if(status == U_BUFFER_OVERFLOW_ERROR){ | |
| 163 status = U_ZERO_ERROR; /* reset error code */ | |
| 164 if(destLen+1 < MAX_DEST_SIZE){ | |
| 165 dest = destStack; | |
| 166 destLen = func(src,u_strlen(src),dest,destLen+1,options | UIDNA_
ALLOW_UNASSIGNED, &parseError, &status); | |
| 167 /* TODO : compare output with expected */ | |
| 168 if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(de
st,destLen, expected,expectedLen,0,&status)!=0){ | |
| 169 log_err("Did not get the expected result for %s with source
length and both options set.\n",testName); | |
| 170 } | |
| 171 }else{ | |
| 172 log_err( "%s with source length failed. Requires destCapacity >
300\n",testName); | |
| 173 } | |
| 174 } | |
| 175 /*testing query string*/ | |
| 176 if(status != expectedStatus && expectedStatus != U_IDNA_UNASSIGNED_ERROR
){ | |
| 177 log_err( "Did not get the expected error for %s with source length a
nd options set. Expected: %s Got: %s\n",testName, u_errorName(expectedStatus), u
_errorName(status)); | |
| 178 } | |
| 179 } | |
| 180 | |
| 181 status = U_ZERO_ERROR; | |
| 182 destLen = func(src,-1,NULL,0,options | UIDNA_USE_STD3_RULES, &parseError, &s
tatus); | |
| 183 if(status == U_BUFFER_OVERFLOW_ERROR){ | |
| 184 status = U_ZERO_ERROR; /* reset error code*/ | |
| 185 if(destLen+1 < MAX_DEST_SIZE){ | |
| 186 dest = destStack; | |
| 187 destLen = func(src,-1,dest,destLen+1,options | UIDNA_USE_STD3_RULES,
&parseError, &status); | |
| 188 /* TODO : compare output with expected*/ | |
| 189 if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,d
estLen, expected,expectedLen,0,&status)!=0){ | |
| 190 log_err("Did not get the expected result for %s null terminated
source with both options set.\n",testName); | |
| 191 | |
| 192 } | |
| 193 }else{ | |
| 194 log_err( "%s null terminated source failed. Requires destCapacity >
300\n",testName); | |
| 195 } | |
| 196 } | |
| 197 /*testing query string*/ | |
| 198 if(status != expectedStatus){ | |
| 199 log_err( "Did not get the expected error for %s null terminated source w
ith options set. Expected: %s Got: %s\n",testName, u_errorName(expectedStatus),
u_errorName(status)); | |
| 200 } | |
| 201 | |
| 202 status = U_ZERO_ERROR; | |
| 203 | |
| 204 destLen = func(tSrc,tSrcLen,NULL,0,options | UIDNA_USE_STD3_RULES, &parseErr
or, &status); | |
| 205 | |
| 206 if(status == U_BUFFER_OVERFLOW_ERROR){ | |
| 207 status = U_ZERO_ERROR; /* reset error code*/ | |
| 208 if(destLen+1 < MAX_DEST_SIZE){ | |
| 209 dest = destStack; | |
| 210 destLen = func(src,u_strlen(src),dest,destLen+1,options | UIDNA_USE_
STD3_RULES, &parseError, &status); | |
| 211 /* TODO : compare output with expected*/ | |
| 212 if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,d
estLen, expected,expectedLen,0,&status)!=0){ | |
| 213 log_err("Did not get the expected result for %s with source leng
th and both options set.\n",testName); | |
| 214 } | |
| 215 }else{ | |
| 216 log_err( "%s with source length failed. Requires destCapacity > 300
\n",testName); | |
| 217 } | |
| 218 } | |
| 219 /*testing query string*/ | |
| 220 if(status != expectedStatus && expectedStatus != U_IDNA_UNASSIGNED_ERROR){ | |
| 221 log_err( "Did not get the expected error for %s with source length and o
ptions set. Expected: %s Got: %s\n",testName, u_errorName(expectedStatus), u_err
orName(status)); | |
| 222 } | |
| 223 free(tSrc); | |
| 224 } | |
| 225 | |
| 226 static const UChar unicodeIn[][41] ={ | |
| 227 { | |
| 228 0x0644, 0x064A, 0x0647, 0x0645, 0x0627, 0x0628, 0x062A, 0x0643, 0x0644, | |
| 229 0x0645, 0x0648, 0x0634, 0x0639, 0x0631, 0x0628, 0x064A, 0x061F, 0x0000 | |
| 230 }, | |
| 231 { | |
| 232 0x4ED6, 0x4EEC, 0x4E3A, 0x4EC0, 0x4E48, 0x4E0D, 0x8BF4, 0x4E2D, 0x6587, | |
| 233 0x0000 | |
| 234 }, | |
| 235 { | |
| 236 0x0050, 0x0072, 0x006F, 0x010D, 0x0070, 0x0072, 0x006F, 0x0073, 0x0074, | |
| 237 0x011B, 0x006E, 0x0065, 0x006D, 0x006C, 0x0075, 0x0076, 0x00ED, 0x010D, | |
| 238 0x0065, 0x0073, 0x006B, 0x0079, 0x0000 | |
| 239 }, | |
| 240 { | |
| 241 0x05DC, 0x05DE, 0x05D4, 0x05D4, 0x05DD, 0x05E4, 0x05E9, 0x05D5, 0x05D8, | |
| 242 0x05DC, 0x05D0, 0x05DE, 0x05D3, 0x05D1, 0x05E8, 0x05D9, 0x05DD, 0x05E2, | |
| 243 0x05D1, 0x05E8, 0x05D9, 0x05EA, 0x0000 | |
| 244 }, | |
| 245 { | |
| 246 0x092F, 0x0939, 0x0932, 0x094B, 0x0917, 0x0939, 0x093F, 0x0928, 0x094D, | |
| 247 0x0926, 0x0940, 0x0915, 0x094D, 0x092F, 0x094B, 0x0902, 0x0928, 0x0939, | |
| 248 0x0940, 0x0902, 0x092C, 0x094B, 0x0932, 0x0938, 0x0915, 0x0924, 0x0947, | |
| 249 0x0939, 0x0948, 0x0902, 0x0000 | |
| 250 }, | |
| 251 { | |
| 252 0x306A, 0x305C, 0x307F, 0x3093, 0x306A, 0x65E5, 0x672C, 0x8A9E, 0x3092, | |
| 253 0x8A71, 0x3057, 0x3066, 0x304F, 0x308C, 0x306A, 0x3044, 0x306E, 0x304B, | |
| 254 0x0000 | |
| 255 }, | |
| 256 /* | |
| 257 { | |
| 258 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, | |
| 259 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, | |
| 260 0xC5BC, 0xB9C8, 0xB098, 0xC88B, 0xC744, 0xAE4C, 0x0000 | |
| 261 }, | |
| 262 */ | |
| 263 { | |
| 264 0x043F, 0x043E, 0x0447, 0x0435, 0x043C, 0x0443, 0x0436, 0x0435, 0x043E, | |
| 265 0x043D, 0x0438, 0x043D, 0x0435, 0x0433, 0x043E, 0x0432, 0x043E, 0x0440, | |
| 266 0x044F, 0x0442, 0x043F, 0x043E, 0x0440, 0x0443, 0x0441, 0x0441, 0x043A, | |
| 267 0x0438, 0x0000 | |
| 268 }, | |
| 269 { | |
| 270 0x0050, 0x006F, 0x0072, 0x0071, 0x0075, 0x00E9, 0x006E, 0x006F, 0x0070, | |
| 271 0x0075, 0x0065, 0x0064, 0x0065, 0x006E, 0x0073, 0x0069, 0x006D, 0x0070, | |
| 272 0x006C, 0x0065, 0x006D, 0x0065, 0x006E, 0x0074, 0x0065, 0x0068, 0x0061, | |
| 273 0x0062, 0x006C, 0x0061, 0x0072, 0x0065, 0x006E, 0x0045, 0x0073, 0x0070, | |
| 274 0x0061, 0x00F1, 0x006F, 0x006C, 0x0000 | |
| 275 }, | |
| 276 { | |
| 277 0x4ED6, 0x5011, 0x7232, 0x4EC0, 0x9EBD, 0x4E0D, 0x8AAA, 0x4E2D, 0x6587, | |
| 278 0x0000 | |
| 279 }, | |
| 280 { | |
| 281 0x0054, 0x1EA1, 0x0069, 0x0073, 0x0061, 0x006F, 0x0068, 0x1ECD, 0x006B, | |
| 282 0x0068, 0x00F4, 0x006E, 0x0067, 0x0074, 0x0068, 0x1EC3, 0x0063, 0x0068, | |
| 283 0x1EC9, 0x006E, 0x00F3, 0x0069, 0x0074, 0x0069, 0x1EBF, 0x006E, 0x0067, | |
| 284 0x0056, 0x0069, 0x1EC7, 0x0074, 0x0000 | |
| 285 }, | |
| 286 { | |
| 287 0x0033, 0x5E74, 0x0042, 0x7D44, 0x91D1, 0x516B, 0x5148, 0x751F, 0x0000 | |
| 288 }, | |
| 289 { | |
| 290 0x5B89, 0x5BA4, 0x5948, 0x7F8E, 0x6075, 0x002D, 0x0077, 0x0069, 0x0074, | |
| 291 0x0068, 0x002D, 0x0053, 0x0055, 0x0050, 0x0045, 0x0052, 0x002D, 0x004D, | |
| 292 0x004F, 0x004E, 0x004B, 0x0045, 0x0059, 0x0053, 0x0000 | |
| 293 }, | |
| 294 { | |
| 295 0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x002D, 0x0041, 0x006E, 0x006F, | |
| 296 0x0074, 0x0068, 0x0065, 0x0072, 0x002D, 0x0057, 0x0061, 0x0079, 0x002D, | |
| 297 0x305D, 0x308C, 0x305E, 0x308C, 0x306E, 0x5834, 0x6240, 0x0000 | |
| 298 }, | |
| 299 { | |
| 300 0x3072, 0x3068, 0x3064, 0x5C4B, 0x6839, 0x306E, 0x4E0B, 0x0032, 0x0000 | |
| 301 }, | |
| 302 { | |
| 303 0x004D, 0x0061, 0x006A, 0x0069, 0x3067, 0x004B, 0x006F, 0x0069, 0x3059, | |
| 304 0x308B, 0x0035, 0x79D2, 0x524D, 0x0000 | |
| 305 }, | |
| 306 { | |
| 307 0x30D1, 0x30D5, 0x30A3, 0x30FC, 0x0064, 0x0065, 0x30EB, 0x30F3, 0x30D0, | |
| 308 0x0000 | |
| 309 }, | |
| 310 { | |
| 311 0x305D, 0x306E, 0x30B9, 0x30D4, 0x30FC, 0x30C9, 0x3067, 0x0000 | |
| 312 }, | |
| 313 /* test non-BMP code points */ | |
| 314 { | |
| 315 0xD800, 0xDF00, 0xD800, 0xDF01, 0xD800, 0xDF02, 0xD800, 0xDF03, 0xD800,
0xDF05, | |
| 316 0xD800, 0xDF06, 0xD800, 0xDF07, 0xD800, 0xDF09, 0xD800, 0xDF0A, 0xD800,
0xDF0B, | |
| 317 0x0000 | |
| 318 }, | |
| 319 { | |
| 320 0xD800, 0xDF0D, 0xD800, 0xDF0C, 0xD800, 0xDF1E, 0xD800, 0xDF0F, 0xD800,
0xDF16, | |
| 321 0xD800, 0xDF15, 0xD800, 0xDF14, 0xD800, 0xDF12, 0xD800, 0xDF10, 0xD800,
0xDF20, | |
| 322 0xD800, 0xDF21, | |
| 323 0x0000 | |
| 324 }, | |
| 325 /* Greek */ | |
| 326 { | |
| 327 0x03b5, 0x03bb, 0x03bb, 0x03b7, 0x03bd, 0x03b9, 0x03ba, 0x03ac | |
| 328 }, | |
| 329 /* Maltese */ | |
| 330 { | |
| 331 0x0062, 0x006f, 0x006e, 0x0121, 0x0075, 0x0073, 0x0061, 0x0127, | |
| 332 0x0127, 0x0061 | |
| 333 }, | |
| 334 /* Russian */ | |
| 335 { | |
| 336 0x043f, 0x043e, 0x0447, 0x0435, 0x043c, 0x0443, 0x0436, 0x0435, | |
| 337 0x043e, 0x043d, 0x0438, 0x043d, 0x0435, 0x0433, 0x043e, 0x0432, | |
| 338 0x043e, 0x0440, 0x044f, 0x0442, 0x043f, 0x043e, 0x0440, 0x0443, | |
| 339 0x0441, 0x0441, 0x043a, 0x0438 | |
| 340 }, | |
| 341 { | |
| 342 0x0054,0x0045,0x0053,0x0054 | |
| 343 } | |
| 344 }; | |
| 345 | |
| 346 static const char * const asciiIn[] = { | |
| 347 "xn--egbpdaj6bu4bxfgehfvwxn", | |
| 348 "xn--ihqwcrb4cv8a8dqg056pqjye", | |
| 349 "xn--Proprostnemluvesky-uyb24dma41a", | |
| 350 "xn--4dbcagdahymbxekheh6e0a7fei0b", | |
| 351 "xn--i1baa7eci9glrd9b2ae1bj0hfcgg6iyaf8o0a1dig0cd", | |
| 352 "xn--n8jok5ay5dzabd5bym9f0cm5685rrjetr6pdxa", | |
| 353 /* "xn--989aomsvi5e83db1d2a355cv1e0vak1dwrv93d5xbh15a0dt30a5jpsd879ccm6fea98c",
*/ | |
| 354 "xn--b1abfaaepdrnnbgefbaDotcwatmq2g4l", | |
| 355 "xn--PorqunopuedensimplementehablarenEspaol-fmd56a", | |
| 356 "xn--ihqwctvzc91f659drss3x8bo0yb", | |
| 357 "xn--TisaohkhngthchnitingVit-kjcr8268qyxafd2f1b9g", | |
| 358 "xn--3B-ww4c5e180e575a65lsy2b", | |
| 359 "xn---with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n", | |
| 360 "xn--Hello-Another-Way--fc4qua05auwb3674vfr0b", | |
| 361 "xn--2-u9tlzr9756bt3uc0v", | |
| 362 "xn--MajiKoi5-783gue6qz075azm5e", | |
| 363 "xn--de-jg4avhby1noc0d", | |
| 364 "xn--d9juau41awczczp", | |
| 365 "XN--097CCDEKGHQJK", | |
| 366 "XN--db8CBHEJLGH4E0AL", | |
| 367 "xn--hxargifdar", /* Greek */ | |
| 368 "xn--bonusaa-5bb1da", /* Maltese */ | |
| 369 "xn--b1abfaaepdrnnbgefbadotcwatmq2g4l", /* Russian (Cyrillic)*/ | |
| 370 "TEST" | |
| 371 | |
| 372 }; | |
| 373 | |
| 374 static const char * const domainNames[] = { | |
| 375 "slip129-37-118-146.nc.us.ibm.net", | |
| 376 "saratoga.pe.utexas.edu", | |
| 377 "dial-120-45.ots.utexas.edu", | |
| 378 "woo-085.dorms.waller.net", | |
| 379 "hd30-049.hil.compuserve.com", | |
| 380 "pem203-31.pe.ttu.edu", | |
| 381 "56K-227.MaxTNT3.pdq.net", | |
| 382 "dial-36-2.ots.utexas.edu", | |
| 383 "slip129-37-23-152.ga.us.ibm.net", | |
| 384 "ts45ip119.cadvision.com", | |
| 385 "sdn-ts-004txaustP05.dialsprint.net", | |
| 386 "bar-tnt1s66.erols.com", | |
| 387 "101.st-louis-15.mo.dial-access.att.net", | |
| 388 "h92-245.Arco.COM", | |
| 389 "dial-13-2.ots.utexas.edu", | |
| 390 "net-redynet29.datamarkets.com.ar", | |
| 391 "ccs-shiva28.reacciun.net.ve", | |
| 392 "7.houston-11.tx.dial-access.att.net", | |
| 393 "ingw129-37-120-26.mo.us.ibm.net", | |
| 394 "dialup6.austintx.com", | |
| 395 "dns2.tpao.gov.tr", | |
| 396 "slip129-37-119-194.nc.us.ibm.net", | |
| 397 "cs7.dillons.co.uk.203.119.193.in-addr.arpa", | |
| 398 "swprd1.innovplace.saskatoon.sk.ca", | |
| 399 "bikini.bologna.maraut.it", | |
| 400 "node91.subnet159-198-79.baxter.com", | |
| 401 "cust19.max5.new-york.ny.ms.uu.net", | |
| 402 "balexander.slip.andrew.cmu.edu", | |
| 403 "pool029.max2.denver.co.dynip.alter.net", | |
| 404 "cust49.max9.new-york.ny.ms.uu.net", | |
| 405 "s61.abq-dialin2.hollyberry.com", | |
| 406 "\\u0917\\u0928\\u0947\\u0936.sanjose.ibm.com", /*':'(0x003a) produces U_IDN
A_STD3_ASCII_RULES_ERROR*/ | |
| 407 "www.xn--vea.com", | |
| 408 /* "www.\\u00E0\\u00B3\\u00AF.com",//' ' (0x0020) produces U_IDNA_STD3_ASCII
_RULES_ERROR*/ | |
| 409 "www.\\u00C2\\u00A4.com", | |
| 410 "www.\\u00C2\\u00A3.com", | |
| 411 /* "\\u0025", //'%' (0x0025) produces U_IDNA_STD3_ASCII_RULES_ERROR*/ | |
| 412 /* "\\u005C\\u005C", //'\' (0x005C) produces U_IDNA_STD3_ASCII_RULES_ERROR*/ | |
| 413 /*"@",*/ | |
| 414 /*"\\u002F",*/ | |
| 415 /*"www.\\u0021.com",*/ | |
| 416 /*"www.\\u0024.com",*/ | |
| 417 /*"\\u003f",*/ | |
| 418 /* These yeild U_IDNA_PROHIBITED_ERROR*/ | |
| 419 /*"\\u00CF\\u0082.com",*/ | |
| 420 /*"\\u00CE\\u00B2\\u00C3\\u009Fss.com",*/ | |
| 421 /*"\\u00E2\\u0098\\u00BA.com",*/ | |
| 422 "\\u00C3\\u00BC.com" | |
| 423 | |
| 424 }; | |
| 425 | |
| 426 static void | |
| 427 TestToASCII(){ | |
| 428 | |
| 429 int32_t i; | |
| 430 UChar buf[MAX_DEST_SIZE]; | |
| 431 const char* testName = "uidna_toASCII"; | |
| 432 TestFunc func = uidna_toASCII; | |
| 433 for(i=0;i< (int32_t)(sizeof(unicodeIn)/sizeof(unicodeIn[0])); i++){ | |
| 434 u_charsToUChars(asciiIn[i],buf, (int32_t)strlen(asciiIn[i])+1); | |
| 435 testAPI(unicodeIn[i], buf,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func
); | |
| 436 | |
| 437 } | |
| 438 } | |
| 439 | |
| 440 static void | |
| 441 TestToUnicode(){ | |
| 442 | |
| 443 int32_t i; | |
| 444 UChar buf[MAX_DEST_SIZE]; | |
| 445 const char* testName = "uidna_toUnicode"; | |
| 446 TestFunc func = uidna_toUnicode; | |
| 447 for(i=0;i< (int32_t)(sizeof(asciiIn)/sizeof(asciiIn[0])); i++){ | |
| 448 u_charsToUChars(asciiIn[i],buf, (int32_t)strlen(asciiIn[i])+1); | |
| 449 testAPI(buf,unicodeIn[i],testName,FALSE,U_ZERO_ERROR, TRUE, TRUE, func); | |
| 450 } | |
| 451 } | |
| 452 | |
| 453 | |
| 454 static void | |
| 455 TestIDNToUnicode(){ | |
| 456 int32_t i; | |
| 457 UChar buf[MAX_DEST_SIZE]; | |
| 458 UChar expected[MAX_DEST_SIZE]; | |
| 459 UErrorCode status = U_ZERO_ERROR; | |
| 460 int32_t bufLen = 0; | |
| 461 UParseError parseError; | |
| 462 const char* testName="uidna_IDNToUnicode"; | |
| 463 TestFunc func = uidna_IDNToUnicode; | |
| 464 for(i=0;i< (int32_t)(sizeof(domainNames)/sizeof(domainNames[0])); i++){ | |
| 465 bufLen = (int32_t)strlen(domainNames[i]); | |
| 466 bufLen = u_unescape(domainNames[i],buf, bufLen+1); | |
| 467 func(buf,bufLen,expected,MAX_DEST_SIZE, UIDNA_ALLOW_UNASSIGNED, &parseEr
ror,&status); | |
| 468 if(U_FAILURE(status)){ | |
| 469 log_err_status(status, "%s failed to convert domainNames[%i].Error:
%s \n",testName, i, u_errorName(status)); | |
| 470 break; | |
| 471 } | |
| 472 testAPI(buf,expected,testName,FALSE,U_ZERO_ERROR, TRUE, TRUE, func); | |
| 473 /*test toUnicode with all labels in the string*/ | |
| 474 testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func); | |
| 475 if(U_FAILURE(status)){ | |
| 476 log_err( "%s failed to convert domainNames[%i].Error: %s \n",testNam
e,i, u_errorName(status)); | |
| 477 break; | |
| 478 } | |
| 479 } | |
| 480 | |
| 481 } | |
| 482 | |
| 483 static void | |
| 484 TestIDNToASCII(){ | |
| 485 int32_t i; | |
| 486 UChar buf[MAX_DEST_SIZE]; | |
| 487 UChar expected[MAX_DEST_SIZE]; | |
| 488 UErrorCode status = U_ZERO_ERROR; | |
| 489 int32_t bufLen = 0; | |
| 490 UParseError parseError; | |
| 491 const char* testName="udina_IDNToASCII"; | |
| 492 TestFunc func=uidna_IDNToASCII; | |
| 493 | |
| 494 for(i=0;i< (int32_t)(sizeof(domainNames)/sizeof(domainNames[0])); i++){ | |
| 495 bufLen = (int32_t)strlen(domainNames[i]); | |
| 496 bufLen = u_unescape(domainNames[i],buf, bufLen+1); | |
| 497 func(buf,bufLen,expected,MAX_DEST_SIZE, UIDNA_ALLOW_UNASSIGNED, &parseEr
ror,&status); | |
| 498 if(U_FAILURE(status)){ | |
| 499 log_err_status(status, "%s failed to convert domainNames[%i].Error:
%s \n",testName,i, u_errorName(status)); | |
| 500 break; | |
| 501 } | |
| 502 testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func); | |
| 503 /*test toASCII with all labels in the string*/ | |
| 504 testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, FALSE, TRUE, func); | |
| 505 if(U_FAILURE(status)){ | |
| 506 log_err( "%s failed to convert domainNames[%i].Error: %s \n",testNam
e,i, u_errorName(status)); | |
| 507 break; | |
| 508 } | |
| 509 } | |
| 510 | |
| 511 | |
| 512 } | |
| 513 | |
| 514 | |
| 515 static void | |
| 516 testCompareWithSrc(const UChar* s1, int32_t s1Len, | |
| 517 const UChar* s2, int32_t s2Len, | |
| 518 const char* testName, CompareFunc func, | |
| 519 UBool isEqual){ | |
| 520 | |
| 521 UErrorCode status = U_ZERO_ERROR; | |
| 522 int32_t retVal = func(s1,-1,s2,-1,UIDNA_DEFAULT,&status); | |
| 523 | |
| 524 if(isEqual==TRUE && retVal !=0){ | |
| 525 log_err("Did not get the expected result for %s with null termniated str
ings.\n",testName); | |
| 526 } | |
| 527 if(U_FAILURE(status)){ | |
| 528 log_err_status(status, "%s null terminated source failed. Error: %s\n",
testName,u_errorName(status)); | |
| 529 } | |
| 530 | |
| 531 status = U_ZERO_ERROR; | |
| 532 retVal = func(s1,-1,s2,-1,UIDNA_ALLOW_UNASSIGNED,&status); | |
| 533 | |
| 534 if(isEqual==TRUE && retVal !=0){ | |
| 535 log_err("Did not get the expected result for %s with null termniated str
ings with options set.\n", testName); | |
| 536 } | |
| 537 if(U_FAILURE(status)){ | |
| 538 log_err_status(status, "%s null terminated source and options set failed
. Error: %s\n",testName, u_errorName(status)); | |
| 539 } | |
| 540 | |
| 541 status = U_ZERO_ERROR; | |
| 542 retVal = func(s1,s1Len,s2,s2Len,UIDNA_DEFAULT,&status); | |
| 543 | |
| 544 if(isEqual==TRUE && retVal !=0){ | |
| 545 log_err("Did not get the expected result for %s with string length.\n",t
estName); | |
| 546 } | |
| 547 if(U_FAILURE(status)){ | |
| 548 log_err_status(status, "%s with string length. Error: %s\n",testName, u
_errorName(status)); | |
| 549 } | |
| 550 | |
| 551 status = U_ZERO_ERROR; | |
| 552 retVal = func(s1,s1Len,s2,s2Len,UIDNA_ALLOW_UNASSIGNED,&status); | |
| 553 | |
| 554 if(isEqual==TRUE && retVal !=0){ | |
| 555 log_err("Did not get the expected result for %s with string length and o
ptions set.\n",testName); | |
| 556 } | |
| 557 if(U_FAILURE(status)){ | |
| 558 log_err_status(status, "%s with string length and options set. Error: %
s\n", u_errorName(status), testName); | |
| 559 } | |
| 560 } | |
| 561 | |
| 562 | |
| 563 static void | |
| 564 TestCompare(){ | |
| 565 int32_t i; | |
| 566 | |
| 567 const char* testName ="uidna_compare"; | |
| 568 CompareFunc func = uidna_compare; | |
| 569 | |
| 570 UChar www[] = {0x0057, 0x0057, 0x0057, 0x002E, 0x0000}; | |
| 571 UChar com[] = {0x002E, 0x0043, 0x004F, 0x004D, 0x0000}; | |
| 572 UChar buf[MAX_DEST_SIZE]={0x0057, 0x0057, 0x0057, 0x002E, 0x0000}; | |
| 573 UChar source[MAX_DEST_SIZE]={0}, | |
| 574 uni0[MAX_DEST_SIZE]={0}, | |
| 575 uni1[MAX_DEST_SIZE]={0}, | |
| 576 ascii0[MAX_DEST_SIZE]={0}, | |
| 577 ascii1[MAX_DEST_SIZE]={0}, | |
| 578 temp[MAX_DEST_SIZE] ={0}; | |
| 579 | |
| 580 | |
| 581 u_strcat(uni0,unicodeIn[0]); | |
| 582 u_strcat(uni0,com); | |
| 583 | |
| 584 u_strcat(uni1,unicodeIn[1]); | |
| 585 u_strcat(uni1,com); | |
| 586 | |
| 587 u_charsToUChars(asciiIn[0], temp, (int32_t)strlen(asciiIn[0])); | |
| 588 u_strcat(ascii0,temp); | |
| 589 u_strcat(ascii0,com); | |
| 590 | |
| 591 memset(temp, 0, U_SIZEOF_UCHAR * MAX_DEST_SIZE); | |
| 592 | |
| 593 u_charsToUChars(asciiIn[1], temp, (int32_t)strlen(asciiIn[1])); | |
| 594 u_strcat(ascii1,temp); | |
| 595 u_strcat(ascii1,com); | |
| 596 | |
| 597 /* prepend www. */ | |
| 598 u_strcat(source, www); | |
| 599 | |
| 600 for(i=0;i< (int32_t)(sizeof(unicodeIn)/sizeof(unicodeIn[0])); i++){ | |
| 601 UChar* src; | |
| 602 int32_t srcLen; | |
| 603 | |
| 604 memset(buf+4, 0, (MAX_DEST_SIZE-4) * U_SIZEOF_UCHAR); | |
| 605 | |
| 606 u_charsToUChars(asciiIn[i],buf+4, (int32_t)strlen(asciiIn[i])); | |
| 607 u_strcat(buf,com); | |
| 608 | |
| 609 | |
| 610 /* for every entry in unicodeIn array | |
| 611 prepend www. and append .com*/ | |
| 612 source[4]=0; | |
| 613 u_strncat(source,unicodeIn[i], u_strlen(unicodeIn[i])); | |
| 614 u_strcat(source,com); | |
| 615 | |
| 616 /* a) compare it with itself*/ | |
| 617 src = source; | |
| 618 srcLen = u_strlen(src); | |
| 619 | |
| 620 testCompareWithSrc(src,srcLen,src,srcLen,testName, func, TRUE); | |
| 621 | |
| 622 /* b) compare it with asciiIn equivalent */ | |
| 623 testCompareWithSrc(src,srcLen,buf,u_strlen(buf),testName, func,TRUE); | |
| 624 | |
| 625 /* c) compare it with unicodeIn not equivalent*/ | |
| 626 if(i==0){ | |
| 627 testCompareWithSrc(src,srcLen,uni1,u_strlen(uni1),testName, func,FAL
SE); | |
| 628 }else{ | |
| 629 testCompareWithSrc(src,srcLen,uni0,u_strlen(uni0),testName, func,FAL
SE); | |
| 630 } | |
| 631 /* d) compare it with asciiIn not equivalent */ | |
| 632 if(i==0){ | |
| 633 testCompareWithSrc(src,srcLen,ascii1,u_strlen(ascii1),testName, func
,FALSE); | |
| 634 }else{ | |
| 635 testCompareWithSrc(src,srcLen,ascii0,u_strlen(ascii0),testName, func
,FALSE); | |
| 636 } | |
| 637 | |
| 638 } | |
| 639 } | |
| 640 | |
| 641 static void TestJB4490(){ | |
| 642 static const UChar data[][50]= { | |
| 643 {0x00F5,0x00dE,0x00dF,0x00dD, 0x0000}, | |
| 644 {0xFB00,0xFB01} | |
| 645 }; | |
| 646 UChar output1[40] = {0}; | |
| 647 UChar output2[40] = {0}; | |
| 648 int32_t i; | |
| 649 for(i=0; i< sizeof(data)/sizeof(data[0]); i++){ | |
| 650 const UChar* src1 = data[i]; | |
| 651 int32_t src1Len = u_strlen(src1); | |
| 652 UChar* dest1 = output1; | |
| 653 int32_t dest1Len = 40; | |
| 654 UErrorCode status = U_ZERO_ERROR; | |
| 655 UParseError ps; | |
| 656 UChar* src2 = NULL; | |
| 657 int32_t src2Len = 0; | |
| 658 UChar* dest2 = output2; | |
| 659 int32_t dest2Len = 40; | |
| 660 dest1Len = uidna_toASCII(src1, src1Len, dest1, dest1Len,UIDNA_DEFAULT, &
ps, &status); | |
| 661 if(U_FAILURE(status)){ | |
| 662 log_err_status(status, "uidna_toUnicode failed with error %s.\n", u_
errorName(status)); | |
| 663 } | |
| 664 src2 = dest1; | |
| 665 src2Len = dest1Len; | |
| 666 dest2Len = uidna_toUnicode(src2, src2Len, dest2, dest2Len, UIDNA_DEFAULT
, &ps, &status); | |
| 667 if(U_FAILURE(status)){ | |
| 668 log_err_status(status, "uidna_toUnicode failed with error %s.\n", u_
errorName(status)); | |
| 669 } | |
| 670 } | |
| 671 } | |
| 672 | |
| 673 static void TestJB4475(){ | |
| 674 | |
| 675 static const UChar input[][10] = { | |
| 676 {0x0054,0x0045,0x0053,0x0054,0x0000},/* TEST */ | |
| 677 {0x0074,0x0065,0x0073,0x0074,0x0000} /* test */ | |
| 678 }; | |
| 679 int i; | |
| 680 UChar output[40] = {0}; | |
| 681 for(i=0; i< sizeof(input)/sizeof(input[0]); i++){ | |
| 682 const UChar* src = input[i]; | |
| 683 int32_t srcLen = u_strlen(src); | |
| 684 UChar* dest = output; | |
| 685 int32_t destLen = 40; | |
| 686 UErrorCode status = U_ZERO_ERROR; | |
| 687 UParseError ps; | |
| 688 | |
| 689 destLen = uidna_toASCII(src, srcLen, dest, destLen,UIDNA_DEFAULT, &ps, &
status); | |
| 690 if(U_FAILURE(status)){ | |
| 691 log_err_status(status, "uidna_toASCII failed with error %s.\n", u_er
rorName(status)); | |
| 692 continue; | |
| 693 } | |
| 694 if(u_strncmp(input[i], dest, srcLen)!=0){ | |
| 695 log_err("uidna_toASCII did not return the expected output.\n"); | |
| 696 } | |
| 697 } | |
| 698 } | |
| 699 | |
| 700 static void TestLength(){ | |
| 701 { | |
| 702 static const char* cl = "my_very_very_very_very_very_very_very_very_very
_very_very_very_very_long_and_incredibly_uncreative_domain_label"; | |
| 703 UChar ul[128] = {'\0'}; | |
| 704 UChar dest[256] = {'\0'}; | |
| 705 /* this unicode string is longer than MAX_LABEL_BUFFER_SIZE and produces
an | |
| 706 IDNA prepared string (including xn--)that is exactly 63 bytes long */ | |
| 707 UChar ul1[] = { 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C,
0xB4E4, 0xC774, | |
| 708 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0x00AD, 0x034F,
0x1806, 0x180B, | |
| 709 0x180C, 0x180D, 0x200B, 0x200C, 0x200D, 0x2060, 0xFE00,
0xFE01, 0xFE02, | |
| 710 0xFE03, 0xFE04, 0xFE05, 0xFE06, 0xFE07, 0xFE08, 0xFE09,
0xFE0A, 0xFE0B, | |
| 711 0xFE0C, 0xFE0D, 0xFE0E, 0xFE0F, 0xFEFF, 0xD574, 0xD55C,
0xB2E4, 0xBA74, | |
| 712 0xC138, 0x0041, 0x00AD, 0x034F, 0x1806, 0x180B, 0x180C,
0x180D, 0x200B, | |
| 713 0x200C, 0x200D, 0x2060, 0xFE00, 0xFE01, 0xFE02, 0xFE03,
0xFE04, 0xFE05, | |
| 714 0xFE06, 0xFE07, 0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C,
0xFE0D, 0xFE0E, | |
| 715 0xFE0F, 0xFEFF, 0x00AD, 0x034F, 0x1806, 0x180B, 0x180C,
0x180D, 0x200B, | |
| 716 0x200C, 0x200D, 0x2060, 0xFE00, 0xFE01, 0xFE02, 0xFE03,
0xFE04, 0xFE05, | |
| 717 0xFE06, 0xFE07, 0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C,
0xFE0D, 0xFE0E, | |
| 718 0xFE0F, 0xFEFF, 0x00AD, 0x034F, 0x1806, 0x180B, 0x180C,
0x180D, 0x200B, | |
| 719 0x200C, 0x200D, 0x2060, 0xFE00, 0xFE01, 0xFE02, 0xFE03,
0xFE04, 0xFE05, | |
| 720 0xFE06, 0xFE07, 0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C,
0xFE0D, 0xFE0E, | |
| 721 0xFE0F, 0xFEFF, 0x0000 | |
| 722 }; | |
| 723 | |
| 724 int32_t len1 = UPRV_LENGTHOF(ul1)-1/*remove the null termination*/; | |
| 725 int32_t destLen = UPRV_LENGTHOF(dest); | |
| 726 UErrorCode status = U_ZERO_ERROR; | |
| 727 UParseError ps; | |
| 728 int32_t len = (int32_t)strlen(cl); | |
| 729 u_charsToUChars(cl, ul, len+1); | |
| 730 destLen = uidna_toUnicode(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &s
tatus); | |
| 731 if(status != U_ZERO_ERROR){ | |
| 732 log_err_status(status, "uidna_toUnicode failed with error %s.\n", u_
errorName(status)); | |
| 733 } | |
| 734 | |
| 735 status = U_ZERO_ERROR; | |
| 736 destLen = UPRV_LENGTHOF(dest); | |
| 737 len = -1; | |
| 738 destLen = uidna_toUnicode(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &s
tatus); | |
| 739 if(status != U_ZERO_ERROR){ | |
| 740 log_err_status(status, "uidna_toUnicode failed with error %s.\n", u_
errorName(status)); | |
| 741 } | |
| 742 status = U_ZERO_ERROR; | |
| 743 destLen = UPRV_LENGTHOF(dest); | |
| 744 len = (int32_t)strlen(cl); | |
| 745 destLen = uidna_toASCII(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &sta
tus); | |
| 746 if(status != U_IDNA_LABEL_TOO_LONG_ERROR){ | |
| 747 log_err_status(status, "uidna_toASCII failed with error %s.\n", u_er
rorName(status)); | |
| 748 } | |
| 749 | |
| 750 status = U_ZERO_ERROR; | |
| 751 destLen = UPRV_LENGTHOF(dest); | |
| 752 len = -1; | |
| 753 destLen = uidna_toASCII(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &sta
tus); | |
| 754 if(status != U_IDNA_LABEL_TOO_LONG_ERROR){ | |
| 755 log_err_status(status, "uidna_toASCII failed with error %s.\n", u_er
rorName(status)); | |
| 756 } | |
| 757 | |
| 758 status = U_ZERO_ERROR; | |
| 759 destLen = UPRV_LENGTHOF(dest); | |
| 760 destLen = uidna_toASCII(ul1, len1, dest, destLen, UIDNA_DEFAULT, &ps, &s
tatus); | |
| 761 if(status != U_ZERO_ERROR){ | |
| 762 log_err_status(status, "uidna_toASCII failed with error %s.\n", u_er
rorName(status)); | |
| 763 } | |
| 764 | |
| 765 status = U_ZERO_ERROR; | |
| 766 destLen = UPRV_LENGTHOF(dest); | |
| 767 len1 = -1; | |
| 768 destLen = uidna_toASCII(ul1, len1, dest, destLen, UIDNA_DEFAULT, &ps, &s
tatus); | |
| 769 if(status != U_ZERO_ERROR){ | |
| 770 log_err_status(status, "uidna_toASCII failed with error %s.\n", u_er
rorName(status)); | |
| 771 } | |
| 772 } | |
| 773 { | |
| 774 static const char* cl = "my_very_very_long_and_incredibly_uncreative_dom
ain_label.my_very_very_long_and_incredibly_uncreative_domain_label.my_very_very_
long_and_incredibly_uncreative_domain_label.my_very_very_long_and_incredibly_unc
reative_domain_label.my_very_very_long_and_incredibly_uncreative_domain_label.my
_very_very_long_and_incredibly_uncreative_domain_label.ibm.com"; | |
| 775 UChar ul[400] = {'\0'}; | |
| 776 UChar dest[400] = {'\0'}; | |
| 777 int32_t destLen = UPRV_LENGTHOF(dest); | |
| 778 UErrorCode status = U_ZERO_ERROR; | |
| 779 UParseError ps; | |
| 780 int32_t len = (int32_t)strlen(cl); | |
| 781 u_charsToUChars(cl, ul, len+1); | |
| 782 | |
| 783 destLen = uidna_IDNToUnicode(ul, len, dest, destLen, UIDNA_DEFAULT, &ps,
&status); | |
| 784 if(status != U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR){ | |
| 785 log_err_status(status, "uidna_IDNToUnicode failed with error %s.\n",
u_errorName(status)); | |
| 786 } | |
| 787 | |
| 788 status = U_ZERO_ERROR; | |
| 789 destLen = UPRV_LENGTHOF(dest); | |
| 790 len = -1; | |
| 791 destLen = uidna_IDNToUnicode(ul, len, dest, destLen, UIDNA_DEFAULT, &ps,
&status); | |
| 792 if(status != U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR){ | |
| 793 log_err_status(status, "uidna_IDNToUnicode failed with error %s.\n",
u_errorName(status)); | |
| 794 } | |
| 795 | |
| 796 status = U_ZERO_ERROR; | |
| 797 destLen = UPRV_LENGTHOF(dest); | |
| 798 len = (int32_t)strlen(cl); | |
| 799 destLen = uidna_IDNToASCII(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &
status); | |
| 800 if(status != U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR){ | |
| 801 log_err_status(status, "uidna_IDNToASCII failed with error %s.\n", u
_errorName(status)); | |
| 802 } | |
| 803 | |
| 804 status = U_ZERO_ERROR; | |
| 805 destLen = UPRV_LENGTHOF(dest); | |
| 806 len = -1; | |
| 807 destLen = uidna_IDNToASCII(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &
status); | |
| 808 if(status != U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR){ | |
| 809 log_err_status(status, "uidna_IDNToASCII failed with error %s.\n", u
_errorName(status)); | |
| 810 } | |
| 811 | |
| 812 status = U_ZERO_ERROR; | |
| 813 uidna_compare(ul, len, ul, len, UIDNA_DEFAULT, &status); | |
| 814 if(status != U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR){ | |
| 815 log_err_status(status, "uidna_compare failed with error %s.\n", u_er
rorName(status)); | |
| 816 } | |
| 817 uidna_compare(ul, -1, ul, -1, UIDNA_DEFAULT, &status); | |
| 818 if(status != U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR){ | |
| 819 log_err_status(status, "uidna_compare failed with error %s.\n", u_er
rorName(status)); | |
| 820 } | |
| 821 } | |
| 822 } | |
| 823 static void TestJB5273(){ | |
| 824 static const char INVALID_DOMAIN_NAME[] = "xn--m\\u00FCller.de"; | |
| 825 UChar invalid_idn[25] = {'\0'}; | |
| 826 int32_t len = u_unescape(INVALID_DOMAIN_NAME, invalid_idn, strlen(INVALID_DO
MAIN_NAME)); | |
| 827 UChar output[50] = {'\0'}; | |
| 828 UErrorCode status = U_ZERO_ERROR; | |
| 829 UParseError prsError; | |
| 830 int32_t outLen = uidna_toUnicode(invalid_idn, len, output, 50, UIDNA_DEFAULT
, &prsError, &status); | |
| 831 (void)outLen; /* Suppress set but not used warning. */ | |
| 832 if(U_FAILURE(status)){ | |
| 833 log_err_status(status, "uidna_toUnicode failed with error: %s\n", u_erro
rName(status)); | |
| 834 } | |
| 835 status = U_ZERO_ERROR; | |
| 836 outLen = uidna_toUnicode(invalid_idn, len, output, 50, UIDNA_USE_STD3_RULES,
&prsError, &status); | |
| 837 if(U_FAILURE(status)){ | |
| 838 log_err_status(status, "uidna_toUnicode failed with error: %s\n", u_erro
rName(status)); | |
| 839 } | |
| 840 | |
| 841 status = U_ZERO_ERROR; | |
| 842 outLen = uidna_IDNToUnicode(invalid_idn, len, output, 50, UIDNA_DEFAULT, &pr
sError, &status); | |
| 843 if(U_FAILURE(status)){ | |
| 844 log_err_status(status, "uidna_toUnicode failed with error: %s\n", u_erro
rName(status)); | |
| 845 } | |
| 846 status = U_ZERO_ERROR; | |
| 847 outLen = uidna_IDNToUnicode(invalid_idn, len, output, 50, UIDNA_USE_STD3_RUL
ES, &prsError, &status); | |
| 848 if(U_FAILURE(status)){ | |
| 849 log_err_status(status, "uidna_toUnicode failed with error: %s\n", u_erro
rName(status)); | |
| 850 } | |
| 851 } | |
| 852 | |
| 853 /* | |
| 854 * Test the new (ICU 4.6/2010) C API that was added for UTS #46. | |
| 855 * Just an API test: Functionality is tested via C++ intltest. | |
| 856 */ | |
| 857 static void TestUTS46() { | |
| 858 static const UChar fA_sharps16[] = { 0x66, 0x41, 0xdf, 0 }; | |
| 859 static const char fA_sharps8[] = { 0x66, 0x41, (char)0xc3, (char)0x9f, 0 }; | |
| 860 static const UChar fa_sharps16[] = { 0x66, 0x61, 0xdf, 0 }; | |
| 861 static const char fa_sharps8[] = { 0x66, 0x61, (char)0xc3, (char)0x9f, 0 }; | |
| 862 static const UChar fass16[] = { 0x66, 0x61, 0x73, 0x73, 0 }; | |
| 863 static const char fass8[] = { 0x66, 0x61, 0x73, 0x73, 0 }; | |
| 864 static const UChar fA_BEL[] = { 0x66, 0x41, 7, 0 }; | |
| 865 static const UChar fa_FFFD[] = { 0x66, 0x61, 0xfffd, 0 }; | |
| 866 | |
| 867 UChar dest16[10]; | |
| 868 char dest8[10]; | |
| 869 int32_t length; | |
| 870 | |
| 871 UIDNAInfo info = UIDNA_INFO_INITIALIZER; | |
| 872 UErrorCode errorCode = U_ZERO_ERROR; | |
| 873 UIDNA *uts46 = uidna_openUTS46(UIDNA_USE_STD3_RULES|UIDNA_NONTRANSITIONAL_TO
_UNICODE, | |
| 874 &errorCode); | |
| 875 if(U_FAILURE(errorCode)) { | |
| 876 log_err_status(errorCode, "uidna_openUTS46() failed: %s\n", u_errorName(
errorCode)); | |
| 877 return; | |
| 878 } | |
| 879 | |
| 880 /* These calls should succeed. */ | |
| 881 length = uidna_labelToASCII(uts46, fA_sharps16, -1, | |
| 882 dest16, UPRV_LENGTHOF(dest16), &info, &errorCode
); | |
| 883 if( U_FAILURE(errorCode) || length != 4 || 0 != u_memcmp(dest16, fass16, 5)
|| | |
| 884 !info.isTransitionalDifferent || info.errors != 0 | |
| 885 ) { | |
| 886 log_err("uidna_labelToASCII() failed: %s\n", u_errorName(errorCode)); | |
| 887 } | |
| 888 errorCode = U_ZERO_ERROR; | |
| 889 length = uidna_labelToUnicode(uts46, fA_sharps16, u_strlen(fA_sharps16), | |
| 890 dest16, UPRV_LENGTHOF(dest16), &info, &errorCo
de); | |
| 891 if( U_FAILURE(errorCode) || length != 3 || 0 != u_memcmp(dest16, fa_sharps16
, 4) || | |
| 892 !info.isTransitionalDifferent || info.errors != 0 | |
| 893 ) { | |
| 894 log_err("uidna_labelToUnicode() failed: %s\n", u_errorName(errorCode)); | |
| 895 } | |
| 896 errorCode = U_ZERO_ERROR; | |
| 897 length = uidna_nameToASCII(uts46, fA_sharps16, u_strlen(fA_sharps16), | |
| 898 dest16, 4, &info, &errorCode); | |
| 899 if( errorCode != U_STRING_NOT_TERMINATED_WARNING || | |
| 900 length != 4 || 0 != u_memcmp(dest16, fass16, 4) || | |
| 901 !info.isTransitionalDifferent || info.errors != 0 | |
| 902 ) { | |
| 903 log_err("uidna_nameToASCII() failed: %s\n", u_errorName(errorCode)); | |
| 904 } | |
| 905 errorCode = U_ZERO_ERROR; | |
| 906 length = uidna_nameToUnicode(uts46, fA_sharps16, -1, | |
| 907 dest16, 3, &info, &errorCode); | |
| 908 if( errorCode != U_STRING_NOT_TERMINATED_WARNING || | |
| 909 length != 3 || 0 != u_memcmp(dest16, fa_sharps16, 3) || | |
| 910 !info.isTransitionalDifferent || info.errors != 0 | |
| 911 ) { | |
| 912 log_err("uidna_nameToUnicode() failed: %s\n", u_errorName(errorCode)); | |
| 913 } | |
| 914 | |
| 915 errorCode = U_ZERO_ERROR; | |
| 916 length = uidna_labelToASCII_UTF8(uts46, fA_sharps8, -1, | |
| 917 dest8, UPRV_LENGTHOF(dest8), &info, &errorC
ode); | |
| 918 if( U_FAILURE(errorCode) || length != 4 || 0 != memcmp(dest8, fass8, 5) || | |
| 919 !info.isTransitionalDifferent || info.errors != 0 | |
| 920 ) { | |
| 921 log_err("uidna_labelToASCII_UTF8() failed: %s\n", u_errorName(errorCode)
); | |
| 922 } | |
| 923 errorCode = U_ZERO_ERROR; | |
| 924 length = uidna_labelToUnicodeUTF8(uts46, fA_sharps8, strlen(fA_sharps8), | |
| 925 dest8, UPRV_LENGTHOF(dest8), &info, &error
Code); | |
| 926 if( U_FAILURE(errorCode) || length != 4 || 0 != memcmp(dest8, fa_sharps8, 5)
|| | |
| 927 !info.isTransitionalDifferent || info.errors != 0 | |
| 928 ) { | |
| 929 log_err("uidna_labelToUnicodeUTF8() failed: %s\n", u_errorName(errorCode
)); | |
| 930 } | |
| 931 errorCode = U_ZERO_ERROR; | |
| 932 length = uidna_nameToASCII_UTF8(uts46, fA_sharps8, strlen(fA_sharps8), | |
| 933 dest8, 4, &info, &errorCode); | |
| 934 if( errorCode != U_STRING_NOT_TERMINATED_WARNING || | |
| 935 length != 4 || 0 != memcmp(dest8, fass8, 4) || | |
| 936 !info.isTransitionalDifferent || info.errors != 0 | |
| 937 ) { | |
| 938 log_err("uidna_nameToASCII_UTF8() failed: %s\n", u_errorName(errorCode))
; | |
| 939 } | |
| 940 errorCode = U_ZERO_ERROR; | |
| 941 length = uidna_nameToUnicodeUTF8(uts46, fA_sharps8, -1, | |
| 942 dest8, 4, &info, &errorCode); | |
| 943 if( errorCode != U_STRING_NOT_TERMINATED_WARNING || | |
| 944 length != 4 || 0 != memcmp(dest8, fa_sharps8, 4) || | |
| 945 !info.isTransitionalDifferent || info.errors != 0 | |
| 946 ) { | |
| 947 log_err("uidna_nameToUnicodeUTF8() failed: %s\n", u_errorName(errorCode)
); | |
| 948 } | |
| 949 | |
| 950 errorCode = U_ZERO_ERROR; | |
| 951 length = uidna_nameToASCII(uts46, NULL, 0, | |
| 952 dest16, 0, &info, &errorCode); | |
| 953 if( errorCode != U_STRING_NOT_TERMINATED_WARNING || | |
| 954 length != 0 || | |
| 955 info.isTransitionalDifferent || info.errors != UIDNA_ERROR_EMPTY_LABEL | |
| 956 ) { | |
| 957 log_err("uidna_nameToASCII(empty) failed: %s\n", u_errorName(errorCode))
; | |
| 958 } | |
| 959 errorCode = U_ZERO_ERROR; | |
| 960 length = uidna_nameToUnicode(uts46, fA_BEL, -1, | |
| 961 dest16, 3, &info, &errorCode); | |
| 962 if( errorCode != U_STRING_NOT_TERMINATED_WARNING || | |
| 963 length != 3 || 0 != u_memcmp(dest16, fa_FFFD, 3) || | |
| 964 info.isTransitionalDifferent || info.errors == 0 | |
| 965 ) { | |
| 966 log_err("uidna_nameToUnicode(fa<BEL>) failed: %s\n", u_errorName(errorCo
de)); | |
| 967 } | |
| 968 | |
| 969 /* These calls should fail. */ | |
| 970 errorCode = U_USELESS_COLLATOR_ERROR; | |
| 971 length = uidna_labelToASCII(uts46, fA_sharps16, -1, | |
| 972 dest16, UPRV_LENGTHOF(dest16), &info, &errorCode
); | |
| 973 if(errorCode != U_USELESS_COLLATOR_ERROR) { | |
| 974 log_err("uidna_labelToASCII(failure) failed: %s\n", u_errorName(errorCod
e)); | |
| 975 } | |
| 976 errorCode = U_ZERO_ERROR; | |
| 977 length = uidna_labelToUnicode(uts46, fA_sharps16, u_strlen(fA_sharps16), | |
| 978 dest16, UPRV_LENGTHOF(dest16), NULL, &errorCod
e); | |
| 979 if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 980 log_err("uidna_labelToUnicode(UIDNAInfo=NULL) failed: %s\n", u_errorName
(errorCode)); | |
| 981 } | |
| 982 errorCode = U_ZERO_ERROR; | |
| 983 length = uidna_nameToASCII(uts46, NULL, u_strlen(fA_sharps16), | |
| 984 dest16, 4, &info, &errorCode); | |
| 985 if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 986 log_err("uidna_nameToASCII(src=NULL) failed: %s\n", u_errorName(errorCod
e)); | |
| 987 } | |
| 988 errorCode = U_ZERO_ERROR; | |
| 989 length = uidna_nameToUnicode(uts46, fA_sharps16, -2, | |
| 990 dest16, 3, &info, &errorCode); | |
| 991 if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 992 log_err("uidna_nameToUnicode(length<-1) failed: %s\n", u_errorName(error
Code)); | |
| 993 } | |
| 994 | |
| 995 errorCode = U_ZERO_ERROR; | |
| 996 length = uidna_labelToASCII_UTF8(uts46, fA_sharps8, -1, | |
| 997 NULL, UPRV_LENGTHOF(dest8), &info, &errorCo
de); | |
| 998 if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 999 log_err("uidna_labelToASCII_UTF8(dest=NULL) failed: %s\n", u_errorName(e
rrorCode)); | |
| 1000 } | |
| 1001 errorCode = U_ZERO_ERROR; | |
| 1002 length = uidna_labelToUnicodeUTF8(uts46, fA_sharps8, strlen(fA_sharps8), | |
| 1003 dest8, -1, &info, &errorCode); | |
| 1004 if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 1005 log_err("uidna_labelToUnicodeUTF8(capacity<0) failed: %s\n", u_errorName
(errorCode)); | |
| 1006 } | |
| 1007 errorCode = U_ZERO_ERROR; | |
| 1008 length = uidna_nameToASCII_UTF8(uts46, dest8, strlen(fA_sharps8), | |
| 1009 dest8, 4, &info, &errorCode); | |
| 1010 if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 1011 log_err("uidna_nameToASCII_UTF8(src==dest!=NULL) failed: %s\n", u_errorN
ame(errorCode)); | |
| 1012 } | |
| 1013 errorCode = U_ZERO_ERROR; | |
| 1014 length = uidna_nameToUnicodeUTF8(uts46, fA_sharps8, -1, | |
| 1015 dest8, 3, &info, &errorCode); | |
| 1016 if(errorCode != U_BUFFER_OVERFLOW_ERROR || length != 4) { | |
| 1017 log_err("uidna_nameToUnicodeUTF8() overflow failed: %s\n", u_errorName(e
rrorCode)); | |
| 1018 } | |
| 1019 | |
| 1020 uidna_close(uts46); | |
| 1021 } | |
| 1022 | |
| 1023 #endif | |
| 1024 | |
| 1025 /* | |
| 1026 * Hey, Emacs, please set the following: | |
| 1027 * | |
| 1028 * Local Variables: | |
| 1029 * indent-tabs-mode: nil | |
| 1030 * End: | |
| 1031 * | |
| 1032 */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
