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