1/* 2 ******************************************************************************* 3 * 4 * Copyright (C) 2003-2012, International Business Machines 5 * Corporation and others. All Rights Reserved. 6 * 7 ******************************************************************************* 8 * file name: testidna.cpp 9 * encoding: US-ASCII 10 * tab size: 8 (not used) 11 * indentation:4 12 * 13 * created on: 2003feb1 14 * created by: Ram Viswanadha 15 */ 16 17#include "unicode/utypes.h" 18 19#if !UCONFIG_NO_IDNA && !UCONFIG_NO_TRANSLITERATION 20 21#include <time.h> 22#include <limits.h> 23#include <stdlib.h> 24#include <string.h> 25#include "unicode/localpointer.h" 26#include "unicode/ustring.h" 27#include "unicode/usprep.h" 28#include "unicode/uniset.h" 29#include "testidna.h" 30#include "idnaref.h" 31#include "nptrans.h" 32#include "unicode/putil.h" 33#include "idnaconf.h" 34 35static const UChar unicodeIn[][41] ={ 36 { 37 0x0644, 0x064A, 0x0647, 0x0645, 0x0627, 0x0628, 0x062A, 0x0643, 0x0644, 38 0x0645, 0x0648, 0x0634, 0x0639, 0x0631, 0x0628, 0x064A, 0x061F, 0x0000 39 }, 40 { 41 0x4ED6, 0x4EEC, 0x4E3A, 0x4EC0, 0x4E48, 0x4E0D, 0x8BF4, 0x4E2D, 0x6587, 42 0x0000 43 }, 44 { 45 0x0050, 0x0072, 0x006F, 0x010D, 0x0070, 0x0072, 0x006F, 0x0073, 0x0074, 46 0x011B, 0x006E, 0x0065, 0x006D, 0x006C, 0x0075, 0x0076, 0x00ED, 0x010D, 47 0x0065, 0x0073, 0x006B, 0x0079, 0x0000 48 }, 49 { 50 0x05DC, 0x05DE, 0x05D4, 0x05D4, 0x05DD, 0x05E4, 0x05E9, 0x05D5, 0x05D8, 51 0x05DC, 0x05D0, 0x05DE, 0x05D3, 0x05D1, 0x05E8, 0x05D9, 0x05DD, 0x05E2, 52 0x05D1, 0x05E8, 0x05D9, 0x05EA, 0x0000 53 }, 54 { 55 0x092F, 0x0939, 0x0932, 0x094B, 0x0917, 0x0939, 0x093F, 0x0928, 0x094D, 56 0x0926, 0x0940, 0x0915, 0x094D, 0x092F, 0x094B, 0x0902, 0x0928, 0x0939, 57 0x0940, 0x0902, 0x092C, 0x094B, 0x0932, 0x0938, 0x0915, 0x0924, 0x0947, 58 0x0939, 0x0948, 0x0902, 0x0000 59 }, 60 { 61 0x306A, 0x305C, 0x307F, 0x3093, 0x306A, 0x65E5, 0x672C, 0x8A9E, 0x3092, 62 0x8A71, 0x3057, 0x3066, 0x304F, 0x308C, 0x306A, 0x3044, 0x306E, 0x304B, 63 0x0000 64 }, 65/* 66 { 67 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, 68 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, 69 0xC5BC, 0xB9C8, 0xB098, 0xC88B, 0xC744, 0xAE4C, 0x0000 70 }, 71*/ 72 { 73 0x043F, 0x043E, 0x0447, 0x0435, 0x043C, 0x0443, 0x0436, 0x0435, 0x043E, 74 0x043D, 0x0438, 0x043D, 0x0435, 0x0433, 0x043E, 0x0432, 0x043E, 0x0440, 75 0x044F, 0x0442, 0x043F, 0x043E, 0x0440, 0x0443, 0x0441, 0x0441, 0x043A, 76 0x0438, 0x0000 77 }, 78 { 79 0x0050, 0x006F, 0x0072, 0x0071, 0x0075, 0x00E9, 0x006E, 0x006F, 0x0070, 80 0x0075, 0x0065, 0x0064, 0x0065, 0x006E, 0x0073, 0x0069, 0x006D, 0x0070, 81 0x006C, 0x0065, 0x006D, 0x0065, 0x006E, 0x0074, 0x0065, 0x0068, 0x0061, 82 0x0062, 0x006C, 0x0061, 0x0072, 0x0065, 0x006E, 0x0045, 0x0073, 0x0070, 83 0x0061, 0x00F1, 0x006F, 0x006C, 0x0000 84 }, 85 { 86 0x4ED6, 0x5011, 0x7232, 0x4EC0, 0x9EBD, 0x4E0D, 0x8AAA, 0x4E2D, 0x6587, 87 0x0000 88 }, 89 { 90 0x0054, 0x1EA1, 0x0069, 0x0073, 0x0061, 0x006F, 0x0068, 0x1ECD, 0x006B, 91 0x0068, 0x00F4, 0x006E, 0x0067, 0x0074, 0x0068, 0x1EC3, 0x0063, 0x0068, 92 0x1EC9, 0x006E, 0x00F3, 0x0069, 0x0074, 0x0069, 0x1EBF, 0x006E, 0x0067, 93 0x0056, 0x0069, 0x1EC7, 0x0074, 0x0000 94 }, 95 { 96 0x0033, 0x5E74, 0x0042, 0x7D44, 0x91D1, 0x516B, 0x5148, 0x751F, 0x0000 97 }, 98 { 99 0x5B89, 0x5BA4, 0x5948, 0x7F8E, 0x6075, 0x002D, 0x0077, 0x0069, 0x0074, 100 0x0068, 0x002D, 0x0053, 0x0055, 0x0050, 0x0045, 0x0052, 0x002D, 0x004D, 101 0x004F, 0x004E, 0x004B, 0x0045, 0x0059, 0x0053, 0x0000 102 }, 103 { 104 0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x002D, 0x0041, 0x006E, 0x006F, 105 0x0074, 0x0068, 0x0065, 0x0072, 0x002D, 0x0057, 0x0061, 0x0079, 0x002D, 106 0x305D, 0x308C, 0x305E, 0x308C, 0x306E, 0x5834, 0x6240, 0x0000 107 }, 108 { 109 0x3072, 0x3068, 0x3064, 0x5C4B, 0x6839, 0x306E, 0x4E0B, 0x0032, 0x0000 110 }, 111 { 112 0x004D, 0x0061, 0x006A, 0x0069, 0x3067, 0x004B, 0x006F, 0x0069, 0x3059, 113 0x308B, 0x0035, 0x79D2, 0x524D, 0x0000 114 }, 115 { 116 0x30D1, 0x30D5, 0x30A3, 0x30FC, 0x0064, 0x0065, 0x30EB, 0x30F3, 0x30D0, 117 0x0000 118 }, 119 { 120 0x305D, 0x306E, 0x30B9, 0x30D4, 0x30FC, 0x30C9, 0x3067, 0x0000 121 }, 122 // test non-BMP code points 123 { 124 0xD800, 0xDF00, 0xD800, 0xDF01, 0xD800, 0xDF02, 0xD800, 0xDF03, 0xD800, 0xDF05, 125 0xD800, 0xDF06, 0xD800, 0xDF07, 0xD800, 0xDF09, 0xD800, 0xDF0A, 0xD800, 0xDF0B, 126 0x0000 127 }, 128 { 129 0xD800, 0xDF0D, 0xD800, 0xDF0C, 0xD800, 0xDF1E, 0xD800, 0xDF0F, 0xD800, 0xDF16, 130 0xD800, 0xDF15, 0xD800, 0xDF14, 0xD800, 0xDF12, 0xD800, 0xDF10, 0xD800, 0xDF20, 131 0xD800, 0xDF21, 132 0x0000 133 }, 134 // Greek 135 { 136 0x03b5, 0x03bb, 0x03bb, 0x03b7, 0x03bd, 0x03b9, 0x03ba, 0x03ac 137 }, 138 // Maltese 139 { 140 0x0062, 0x006f, 0x006e, 0x0121, 0x0075, 0x0073, 0x0061, 0x0127, 141 0x0127, 0x0061 142 }, 143 // Russian 144 { 145 0x043f, 0x043e, 0x0447, 0x0435, 0x043c, 0x0443, 0x0436, 0x0435, 146 0x043e, 0x043d, 0x0438, 0x043d, 0x0435, 0x0433, 0x043e, 0x0432, 147 0x043e, 0x0440, 0x044f, 0x0442, 0x043f, 0x043e, 0x0440, 0x0443, 148 0x0441, 0x0441, 0x043a, 0x0438 149 }, 150 { 151 0xFB00, 0xFB01 152 } 153 154}; 155 156static const char *asciiIn[] = { 157 "xn--egbpdaj6bu4bxfgehfvwxn", 158 "xn--ihqwcrb4cv8a8dqg056pqjye", 159 "xn--Proprostnemluvesky-uyb24dma41a", 160 "xn--4dbcagdahymbxekheh6e0a7fei0b", 161 "xn--i1baa7eci9glrd9b2ae1bj0hfcgg6iyaf8o0a1dig0cd", 162 "xn--n8jok5ay5dzabd5bym9f0cm5685rrjetr6pdxa", 163/* "xn--989aomsvi5e83db1d2a355cv1e0vak1dwrv93d5xbh15a0dt30a5jpsd879ccm6fea98c",*/ 164 "xn--b1abfaaepdrnnbgefbaDotcwatmq2g4l", 165 "xn--PorqunopuedensimplementehablarenEspaol-fmd56a", 166 "xn--ihqwctvzc91f659drss3x8bo0yb", 167 "xn--TisaohkhngthchnitingVit-kjcr8268qyxafd2f1b9g", 168 "xn--3B-ww4c5e180e575a65lsy2b", 169 "xn---with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n", 170 "xn--Hello-Another-Way--fc4qua05auwb3674vfr0b", 171 "xn--2-u9tlzr9756bt3uc0v", 172 "xn--MajiKoi5-783gue6qz075azm5e", 173 "xn--de-jg4avhby1noc0d", 174 "xn--d9juau41awczczp", 175 "XN--097CCDEKGHQJK", 176 "XN--db8CBHEJLGH4E0AL", 177 "xn--hxargifdar", // Greek 178 "xn--bonusaa-5bb1da", // Maltese 179 "xn--b1abfaaepdrnnbgefbadotcwatmq2g4l", // Russian (Cyrillic) 180 "fffi" 181}; 182 183static const char *domainNames[] = { 184 "slip129-37-118-146.nc.us.ibm.net", 185 "saratoga.pe.utexas.edu", 186 "dial-120-45.ots.utexas.edu", 187 "woo-085.dorms.waller.net", 188 "hd30-049.hil.compuserve.com", 189 "pem203-31.pe.ttu.edu", 190 "56K-227.MaxTNT3.pdq.net", 191 "dial-36-2.ots.utexas.edu", 192 "slip129-37-23-152.ga.us.ibm.net", 193 "ts45ip119.cadvision.com", 194 "sdn-ts-004txaustP05.dialsprint.net", 195 "bar-tnt1s66.erols.com", 196 "101.st-louis-15.mo.dial-access.att.net", 197 "h92-245.Arco.COM", 198 "dial-13-2.ots.utexas.edu", 199 "net-redynet29.datamarkets.com.ar", 200 "ccs-shiva28.reacciun.net.ve", 201 "7.houston-11.tx.dial-access.att.net", 202 "ingw129-37-120-26.mo.us.ibm.net", 203 "dialup6.austintx.com", 204 "dns2.tpao.gov.tr", 205 "slip129-37-119-194.nc.us.ibm.net", 206 "cs7.dillons.co.uk.203.119.193.in-addr.arpa", 207 "swprd1.innovplace.saskatoon.sk.ca", 208 "bikini.bologna.maraut.it", 209 "node91.subnet159-198-79.baxter.com", 210 "cust19.max5.new-york.ny.ms.uu.net", 211 "balexander.slip.andrew.cmu.edu", 212 "pool029.max2.denver.co.dynip.alter.net", 213 "cust49.max9.new-york.ny.ms.uu.net", 214 "s61.abq-dialin2.hollyberry.com", 215 "\\u0917\\u0928\\u0947\\u0936.sanjose.ibm.com", //':'(0x003a) produces U_IDNA_STD3_ASCII_RULES_ERROR 216 "www.xn--vea.com", 217 // "www.\\u00E0\\u00B3\\u00AF.com",//' ' (0x0020) produces U_IDNA_STD3_ASCII_RULES_ERROR 218 "www.\\u00C2\\u00A4.com", 219 "www.\\u00C2\\u00A3.com", 220 // "\\u0025", //'%' (0x0025) produces U_IDNA_STD3_ASCII_RULES_ERROR 221 // "\\u005C\\u005C", //'\' (0x005C) produces U_IDNA_STD3_ASCII_RULES_ERROR 222 //"@", 223 //"\\u002F", 224 //"www.\\u0021.com", 225 //"www.\\u0024.com", 226 //"\\u003f", 227 // These yeild U_IDNA_PROHIBITED_ERROR 228 //"\\u00CF\\u0082.com", 229 //"\\u00CE\\u00B2\\u00C3\\u009Fss.com", 230 //"\\u00E2\\u0098\\u00BA.com", 231 "\\u00C3\\u00BC.com", 232 233}; 234 235typedef struct ErrorCases ErrorCases; 236 237static const struct ErrorCases{ 238 239 UChar unicode[100]; 240 const char *ascii; 241 UErrorCode expected; 242 UBool useSTD3ASCIIRules; 243 UBool testToUnicode; 244 UBool testLabel; 245} errorCases[] = { 246 { 247 248 { 249 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ 250 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, 251 0x070F,/*prohibited*/ 252 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, 253 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ 254 0x0000 255 }, 256 "www.XN--8mb5595fsoa28orucya378bqre2tcwop06c5qbw82a1rffmae0361dea96b.com", 257 U_IDNA_PROHIBITED_ERROR, 258 FALSE, FALSE, TRUE 259 }, 260 261 { 262 { 263 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ 264 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, 265 0x0221, 0x0234/*Unassigned code points*/, 266 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ 267 0x0000 268 }, 269 "www.XN--6lA2Bz548Fj1GuA391Bf1Gb1N59Ab29A7iA.com", 270 271 U_IDNA_UNASSIGNED_ERROR, 272 FALSE, FALSE, TRUE 273 }, 274 { 275 { 276 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ 277 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, 278 0x0644, 0x064A, 0x0647,/*Arabic code points. Cannot mix RTL with LTR*/ 279 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, 280 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ 281 0x0000 282 }, 283 "www.xn--ghBGI4851OiyA33VqrD6Az86C4qF83CtRv93D5xBk15AzfG0nAgA0578DeA71C.com", 284 U_IDNA_CHECK_BIDI_ERROR, 285 FALSE, FALSE, TRUE 286 }, 287 { 288 { 289 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ 290 /* labels cannot begin with an HYPHEN */ 291 0x002D, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, 292 0x002E, 293 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, 294 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ 295 0x0000 296 297 }, 298 "www.xn----b95Ew8SqA315Ao5FbuMlnNmhA.com", 299 U_IDNA_STD3_ASCII_RULES_ERROR, 300 TRUE, FALSE, FALSE 301 }, 302 { 303 { 304 /* correct ACE-prefix followed by unicode */ 305 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ 306 0x0078, 0x006e, 0x002d,0x002d, /* ACE Prefix */ 307 0x002D, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, 308 0x002D, 309 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, 310 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ 311 0x0000 312 313 }, 314 /* wrong ACE-prefix followed by valid ACE-encoded ASCII */ 315 "www.XY-----b91I0V65S96C2A355Cw1E5yCeQr19CsnP1mFfmAE0361DeA96B.com", 316 U_IDNA_ACE_PREFIX_ERROR, 317 FALSE, FALSE, FALSE 318 }, 319 /* cannot verify U_IDNA_VERIFICATION_ERROR */ 320 321 { 322 { 323 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ 324 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774, 325 0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74, 326 0xC5BC, 0xB9C8, 0xB098, 0xC88B, 0xC744, 0xAE4C, 327 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ 328 0x0000 329 }, 330 "www.xn--989AoMsVi5E83Db1D2A355Cv1E0vAk1DwRv93D5xBh15A0Dt30A5JpSD879Ccm6FeA98C.com", 331 U_IDNA_LABEL_TOO_LONG_ERROR, 332 FALSE, FALSE, TRUE 333 }, 334 335 { 336 { 337 0x0077, 0x0077, 0x0077, 0x002e, /* www. */ 338 0x0030, 0x0644, 0x064A, 0x0647, 0x0031, /* Arabic code points squashed between EN codepoints */ 339 0x002e, 0x0063, 0x006f, 0x006d, /* com. */ 340 0x0000 341 }, 342 "www.xn--01-tvdmo.com", 343 U_IDNA_CHECK_BIDI_ERROR, 344 FALSE, FALSE, TRUE 345 }, 346 347 { 348 { 349 0x0077, 0x0077, 0x0077, 0x002e, // www. 350 0x206C, 0x0644, 0x064A, 0x0647, 0x206D, // Arabic code points squashed between BN codepoints 351 0x002e, 0x0063, 0x006f, 0x006d, // com. 352 0x0000 353 }, 354 "www.XN--ghbgi278xia.com", 355 U_IDNA_PROHIBITED_ERROR, 356 FALSE, FALSE, TRUE 357 }, 358 { 359 { 360 0x0077, 0x0077, 0x0077, 0x002e, // www. 361 0x002D, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, // HYPHEN at the start of label 362 0x002e, 0x0063, 0x006f, 0x006d, // com. 363 0x0000 364 }, 365 "www.-abcde.com", 366 U_IDNA_STD3_ASCII_RULES_ERROR, 367 TRUE, FALSE, FALSE 368 }, 369 { 370 { 371 0x0077, 0x0077, 0x0077, 0x002e, // www. 372 0x0041, 0x0042, 0x0043, 0x0044, 0x0045,0x002D, // HYPHEN at the end of the label 373 0x002e, 0x0063, 0x006f, 0x006d, // com. 374 0x0000 375 }, 376 "www.abcde-.com", 377 U_IDNA_STD3_ASCII_RULES_ERROR, 378 TRUE, FALSE, FALSE 379 }, 380 { 381 { 382 0x0077, 0x0077, 0x0077, 0x002e, // www. 383 0x0041, 0x0042, 0x0043, 0x0044, 0x0045,0x0040, // Containing non LDH code point 384 0x002e, 0x0063, 0x006f, 0x006d, // com. 385 0x0000 386 }, 387 "www.abcde@.com", 388 U_IDNA_STD3_ASCII_RULES_ERROR, 389 TRUE, FALSE, FALSE 390 }, 391 { 392 { 393 0x0077, 0x0077, 0x0077, 0x002e, // www. 394 // zero length label 395 0x002e, 0x0063, 0x006f, 0x006d, // com. 396 0x0000 397 }, 398 "www..com", 399 U_IDNA_ZERO_LENGTH_LABEL_ERROR, 400 TRUE, FALSE, FALSE 401 }, 402 { 403 {0}, 404 NULL, 405 U_ILLEGAL_ARGUMENT_ERROR, 406 TRUE, TRUE, FALSE 407 } 408}; 409 410 411 412 413#define MAX_DEST_SIZE 300 414 415void TestIDNA::debug(const UChar* src, int32_t srcLength, int32_t options){ 416 UParseError parseError; 417 UErrorCode transStatus = U_ZERO_ERROR; 418 UErrorCode prepStatus = U_ZERO_ERROR; 419 NamePrepTransform* trans = NamePrepTransform::createInstance(parseError,transStatus); 420 int32_t prepOptions = (((options & UIDNA_ALLOW_UNASSIGNED) != 0) ? USPREP_ALLOW_UNASSIGNED: 0); 421 LocalUStringPrepProfilePointer prep(usprep_openByType(USPREP_RFC3491_NAMEPREP,&prepStatus)); 422 UChar *transOut=NULL, *prepOut=NULL; 423 int32_t transOutLength=0, prepOutLength=0; 424 425 426 transOutLength = trans->process(src,srcLength,transOut, 0, prepOptions>0, &parseError, transStatus); 427 if( transStatus == U_BUFFER_OVERFLOW_ERROR){ 428 transStatus = U_ZERO_ERROR; 429 transOut = (UChar*) malloc(U_SIZEOF_UCHAR * transOutLength); 430 transOutLength = trans->process(src,srcLength,transOut, transOutLength, prepOptions>0, &parseError, transStatus); 431 } 432 433 prepOutLength = usprep_prepare(prep.getAlias(), src, srcLength, prepOut, 0, prepOptions, &parseError, &prepStatus); 434 435 if( prepStatus == U_BUFFER_OVERFLOW_ERROR){ 436 prepStatus = U_ZERO_ERROR; 437 prepOut = (UChar*) malloc(U_SIZEOF_UCHAR * prepOutLength); 438 prepOutLength = usprep_prepare(prep.getAlias(), src, srcLength, prepOut, prepOutLength, prepOptions, &parseError, &prepStatus); 439 } 440 441 if(UnicodeString(transOut,transOutLength)!= UnicodeString(prepOut, prepOutLength)){ 442 errln("Failed. Expected: " + prettify(UnicodeString(transOut, transOutLength)) 443 + " Got: " + prettify(UnicodeString(prepOut,prepOutLength))); 444 } 445 free(transOut); 446 free(prepOut); 447 delete trans; 448} 449 450void TestIDNA::testAPI(const UChar* src, const UChar* expected, const char* testName, 451 UBool useSTD3ASCIIRules,UErrorCode expectedStatus, 452 UBool doCompare, UBool testUnassigned, TestFunc func, UBool testSTD3ASCIIRules){ 453 454 UErrorCode status = U_ZERO_ERROR; 455 UChar destStack[MAX_DEST_SIZE]; 456 int32_t destLen = 0; 457 UChar* dest = NULL; 458 int32_t expectedLen = (expected != NULL) ? u_strlen(expected) : 0; 459 int32_t options = (useSTD3ASCIIRules == TRUE) ? UIDNA_USE_STD3_RULES : UIDNA_DEFAULT; 460 UParseError parseError; 461 int32_t tSrcLen = 0; 462 UChar* tSrc = NULL; 463 464 if(src != NULL){ 465 tSrcLen = u_strlen(src); 466 tSrc =(UChar*) malloc( U_SIZEOF_UCHAR * tSrcLen ); 467 memcpy(tSrc,src,tSrcLen * U_SIZEOF_UCHAR); 468 } 469 470 // test null-terminated source and return value of number of UChars required 471 destLen = func(src,-1,NULL,0,options, &parseError , &status); 472 if(status == U_BUFFER_OVERFLOW_ERROR){ 473 status = U_ZERO_ERROR; // reset error code 474 if(destLen+1 < MAX_DEST_SIZE){ 475 dest = destStack; 476 destLen = func(src,-1,dest,destLen+1,options, &parseError, &status); 477 // TODO : compare output with expected 478 if(U_SUCCESS(status) && expectedStatus != U_IDNA_STD3_ASCII_RULES_ERROR&& (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){ 479 errln("Did not get the expected result for "+UnicodeString(testName) +" null terminated source. Expected : " 480 + prettify(UnicodeString(expected,expectedLen)) 481 + " Got: " + prettify(UnicodeString(dest,destLen)) 482 ); 483 } 484 }else{ 485 errln( "%s null terminated source failed. Requires destCapacity > 300\n",testName); 486 } 487 } 488 489 if(status != expectedStatus){ 490 errcheckln(status, "Did not get the expected error for "+ 491 UnicodeString(testName)+ 492 " null terminated source. Expected: " +UnicodeString(u_errorName(expectedStatus)) 493 + " Got: "+ UnicodeString(u_errorName(status)) 494 + " Source: " + prettify(UnicodeString(src)) 495 ); 496 free(tSrc); 497 return; 498 } 499 if(testUnassigned ){ 500 status = U_ZERO_ERROR; 501 destLen = func(src,-1,NULL,0,options | UIDNA_ALLOW_UNASSIGNED, &parseError, &status); 502 if(status == U_BUFFER_OVERFLOW_ERROR){ 503 status = U_ZERO_ERROR; // reset error code 504 if(destLen+1 < MAX_DEST_SIZE){ 505 dest = destStack; 506 destLen = func(src,-1,dest,destLen+1,options | UIDNA_ALLOW_UNASSIGNED, &parseError, &status); 507 // TODO : compare output with expected 508 if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){ 509 //errln("Did not get the expected result for %s null terminated source with both options set.\n",testName); 510 errln("Did not get the expected result for "+UnicodeString(testName) + 511 " null terminated source "+ prettify(src) + 512 " with both options set. Expected: "+ prettify(UnicodeString(expected,expectedLen))+ 513 "Got: " + prettify(UnicodeString(dest,destLen))); 514 515 debug(src,-1,options | UIDNA_ALLOW_UNASSIGNED); 516 517 } 518 }else{ 519 errln( "%s null terminated source failed. Requires destCapacity > 300\n",testName); 520 } 521 } 522 //testing query string 523 if(status != expectedStatus && expectedStatus != U_IDNA_UNASSIGNED_ERROR){ 524 errln( "Did not get the expected error for "+ 525 UnicodeString(testName)+ 526 " null terminated source with options set. Expected: " +UnicodeString(u_errorName(expectedStatus)) 527 + " Got: "+ UnicodeString(u_errorName(status)) 528 + " Source: " + prettify(UnicodeString(src)) 529 ); 530 } 531 } 532 533 status = U_ZERO_ERROR; 534 535 // test source with lengthand return value of number of UChars required 536 destLen = func(tSrc, tSrcLen, NULL,0,options, &parseError, &status); 537 if(status == U_BUFFER_OVERFLOW_ERROR){ 538 status = U_ZERO_ERROR; // reset error code 539 if(destLen+1 < MAX_DEST_SIZE){ 540 dest = destStack; 541 destLen = func(src,u_strlen(src),dest,destLen+1,options, &parseError, &status); 542 // TODO : compare output with expected 543 if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){ 544 errln("Did not get the expected result for %s with source length.\n",testName); 545 } 546 }else{ 547 errln( "%s with source length failed. Requires destCapacity > 300\n",testName); 548 } 549 } 550 551 if(status != expectedStatus){ 552 errln( "Did not get the expected error for "+ 553 UnicodeString(testName)+ 554 " with source length. Expected: " +UnicodeString(u_errorName(expectedStatus)) 555 + " Got: "+ UnicodeString(u_errorName(status)) 556 + " Source: " + prettify(UnicodeString(src)) 557 ); 558 } 559 if(testUnassigned){ 560 status = U_ZERO_ERROR; 561 562 destLen = func(tSrc,tSrcLen,NULL,0,options | UIDNA_ALLOW_UNASSIGNED, &parseError, &status); 563 564 if(status == U_BUFFER_OVERFLOW_ERROR){ 565 status = U_ZERO_ERROR; // reset error code 566 if(destLen+1 < MAX_DEST_SIZE){ 567 dest = destStack; 568 destLen = func(src,u_strlen(src),dest,destLen+1,options | UIDNA_ALLOW_UNASSIGNED, &parseError, &status); 569 // TODO : compare output with expected 570 if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){ 571 errln("Did not get the expected result for %s with source length and both options set.\n",testName); 572 } 573 }else{ 574 errln( "%s with source length failed. Requires destCapacity > 300\n",testName); 575 } 576 } 577 //testing query string 578 if(status != expectedStatus && expectedStatus != U_IDNA_UNASSIGNED_ERROR){ 579 errln( "Did not get the expected error for "+ 580 UnicodeString(testName)+ 581 " with source length and options set. Expected: " +UnicodeString(u_errorName(expectedStatus)) 582 + " Got: "+ UnicodeString(u_errorName(status)) 583 + " Source: " + prettify(UnicodeString(src)) 584 ); 585 } 586 } 587 588 status = U_ZERO_ERROR; 589 if(testSTD3ASCIIRules==TRUE){ 590 destLen = func(src,-1,NULL,0,options | UIDNA_USE_STD3_RULES, &parseError, &status); 591 if(status == U_BUFFER_OVERFLOW_ERROR){ 592 status = U_ZERO_ERROR; // reset error code 593 if(destLen+1 < MAX_DEST_SIZE){ 594 dest = destStack; 595 destLen = func(src,-1,dest,destLen+1,options | UIDNA_USE_STD3_RULES, &parseError, &status); 596 // TODO : compare output with expected 597 if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){ 598 //errln("Did not get the expected result for %s null terminated source with both options set.\n",testName); 599 errln("Did not get the expected result for "+UnicodeString(testName) +" null terminated source with both options set. Expected: "+ prettify(UnicodeString(expected,expectedLen))); 600 601 } 602 }else{ 603 errln( "%s null terminated source failed. Requires destCapacity > 300\n",testName); 604 } 605 } 606 //testing query string 607 if(status != expectedStatus){ 608 errln( "Did not get the expected error for "+ 609 UnicodeString(testName)+ 610 " null terminated source with options set. Expected: " +UnicodeString(u_errorName(expectedStatus)) 611 + " Got: "+ UnicodeString(u_errorName(status)) 612 + " Source: " + prettify(UnicodeString(src)) 613 ); 614 } 615 616 status = U_ZERO_ERROR; 617 618 destLen = func(tSrc,tSrcLen,NULL,0,options | UIDNA_USE_STD3_RULES, &parseError, &status); 619 620 if(status == U_BUFFER_OVERFLOW_ERROR){ 621 status = U_ZERO_ERROR; // reset error code 622 if(destLen+1 < MAX_DEST_SIZE){ 623 dest = destStack; 624 destLen = func(src,u_strlen(src),dest,destLen+1,options | UIDNA_USE_STD3_RULES, &parseError, &status); 625 // TODO : compare output with expected 626 if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){ 627 errln("Did not get the expected result for %s with source length and both options set.\n",testName); 628 } 629 }else{ 630 errln( "%s with source length failed. Requires destCapacity > 300\n",testName); 631 } 632 } 633 //testing query string 634 if(status != expectedStatus && expectedStatus != U_IDNA_UNASSIGNED_ERROR){ 635 errln( "Did not get the expected error for "+ 636 UnicodeString(testName)+ 637 " with source length and options set. Expected: " +UnicodeString(u_errorName(expectedStatus)) 638 + " Got: "+ UnicodeString(u_errorName(status)) 639 + " Source: " + prettify(UnicodeString(src)) 640 ); 641 } 642 } 643 free(tSrc); 644} 645 646void TestIDNA::testCompare(const UChar* s1, int32_t s1Len, 647 const UChar* s2, int32_t s2Len, 648 const char* testName, CompareFunc func, 649 UBool isEqual){ 650 651 UErrorCode status = U_ZERO_ERROR; 652 int32_t retVal = func(s1,-1,s2,-1,UIDNA_DEFAULT,&status); 653 654 if(isEqual==TRUE && retVal !=0){ 655 errln("Did not get the expected result for %s with null termniated strings.\n",testName); 656 } 657 if(U_FAILURE(status)){ 658 errcheckln(status, "%s null terminated source failed. Error: %s", testName,u_errorName(status)); 659 } 660 661 status = U_ZERO_ERROR; 662 retVal = func(s1,-1,s2,-1,UIDNA_ALLOW_UNASSIGNED,&status); 663 664 if(isEqual==TRUE && retVal !=0){ 665 errln("Did not get the expected result for %s with null termniated strings with options set.\n", testName); 666 } 667 if(U_FAILURE(status)){ 668 errcheckln(status, "%s null terminated source and options set failed. Error: %s",testName, u_errorName(status)); 669 } 670 671 status = U_ZERO_ERROR; 672 retVal = func(s1,s1Len,s2,s2Len,UIDNA_DEFAULT,&status); 673 674 if(isEqual==TRUE && retVal !=0){ 675 errln("Did not get the expected result for %s with string length.\n",testName); 676 } 677 if(U_FAILURE(status)){ 678 errcheckln(status, "%s with string length. Error: %s",testName, u_errorName(status)); 679 } 680 681 status = U_ZERO_ERROR; 682 retVal = func(s1,s1Len,s2,s2Len,UIDNA_ALLOW_UNASSIGNED,&status); 683 684 if(isEqual==TRUE && retVal !=0){ 685 errln("Did not get the expected result for %s with string length and options set.\n",testName); 686 } 687 if(U_FAILURE(status)){ 688 errcheckln(status, "%s with string length and options set. Error: %s", u_errorName(status), testName); 689 } 690} 691 692void TestIDNA::testToASCII(const char* testName, TestFunc func){ 693 694 int32_t i; 695 UChar buf[MAX_DEST_SIZE]; 696 697 for(i=0;i< (int32_t)(sizeof(unicodeIn)/sizeof(unicodeIn[0])); i++){ 698 u_charsToUChars(asciiIn[i],buf, (int32_t)(strlen(asciiIn[i])+1)); 699 testAPI(unicodeIn[i], buf,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func); 700 701 } 702} 703 704void TestIDNA::testToUnicode(const char* testName, TestFunc func){ 705 706 int32_t i; 707 UChar buf[MAX_DEST_SIZE]; 708 709 for(i=0;i< (int32_t)(sizeof(asciiIn)/sizeof(asciiIn[0])); i++){ 710 u_charsToUChars(asciiIn[i],buf, (int32_t)(strlen(asciiIn[i])+1)); 711 testAPI(buf,unicodeIn[i],testName,FALSE,U_ZERO_ERROR, TRUE, TRUE, func); 712 } 713} 714 715 716void TestIDNA::testIDNToUnicode(const char* testName, TestFunc func){ 717 int32_t i; 718 UChar buf[MAX_DEST_SIZE]; 719 UChar expected[MAX_DEST_SIZE]; 720 UErrorCode status = U_ZERO_ERROR; 721 int32_t bufLen = 0; 722 UParseError parseError; 723 for(i=0;i< (int32_t)(sizeof(domainNames)/sizeof(domainNames[0])); i++){ 724 bufLen = (int32_t)strlen(domainNames[i]); 725 bufLen = u_unescape(domainNames[i],buf, bufLen+1); 726 func(buf,bufLen,expected,MAX_DEST_SIZE, UIDNA_ALLOW_UNASSIGNED, &parseError,&status); 727 if(U_FAILURE(status)){ 728 errcheckln(status, "%s failed to convert domainNames[%i].Error: %s",testName, i, u_errorName(status)); 729 break; 730 } 731 testAPI(buf,expected,testName,FALSE,U_ZERO_ERROR, TRUE, TRUE, func); 732 //test toUnicode with all labels in the string 733 testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func); 734 if(U_FAILURE(status)){ 735 errln( "%s failed to convert domainNames[%i].Error: %s \n",testName,i, u_errorName(status)); 736 break; 737 } 738 } 739 740} 741 742void TestIDNA::testIDNToASCII(const char* testName, TestFunc func){ 743 int32_t i; 744 UChar buf[MAX_DEST_SIZE]; 745 UChar expected[MAX_DEST_SIZE]; 746 UErrorCode status = U_ZERO_ERROR; 747 int32_t bufLen = 0; 748 UParseError parseError; 749 for(i=0;i< (int32_t)(sizeof(domainNames)/sizeof(domainNames[0])); i++){ 750 bufLen = (int32_t)strlen(domainNames[i]); 751 bufLen = u_unescape(domainNames[i],buf, bufLen+1); 752 func(buf,bufLen,expected,MAX_DEST_SIZE, UIDNA_ALLOW_UNASSIGNED, &parseError,&status); 753 if(U_FAILURE(status)){ 754 errcheckln(status, "%s failed to convert domainNames[%i].Error: %s",testName,i, u_errorName(status)); 755 break; 756 } 757 testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func); 758 //test toASCII with all labels in the string 759 testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, FALSE, TRUE, func); 760 if(U_FAILURE(status)){ 761 errln( "%s failed to convert domainNames[%i].Error: %s \n",testName,i, u_errorName(status)); 762 break; 763 } 764 } 765 766} 767 768void TestIDNA::testCompare(const char* testName, CompareFunc func){ 769 int32_t i; 770 771 772 UChar www[] = {0x0057, 0x0057, 0x0057, 0x002E, 0x0000}; 773 UChar com[] = {0x002E, 0x0043, 0x004F, 0x004D, 0x0000}; 774 UChar buf[MAX_DEST_SIZE]={0x0057, 0x0057, 0x0057, 0x002E, 0x0000}; 775 776 UnicodeString source(www), uni0(www),uni1(www), ascii0(www), ascii1(www); 777 778 uni0.append(unicodeIn[0]); 779 uni0.append(com); 780 uni0.append((UChar)0x0000); 781 782 uni1.append(unicodeIn[1]); 783 uni1.append(com); 784 uni1.append((UChar)0x0000); 785 786 ascii0.append(asciiIn[0]); 787 ascii0.append(com); 788 ascii0.append((UChar)0x0000); 789 790 ascii1.append(asciiIn[1]); 791 ascii1.append(com); 792 ascii1.append((UChar)0x0000); 793 794 for(i=0;i< (int32_t)(sizeof(unicodeIn)/sizeof(unicodeIn[0])); i++){ 795 796 u_charsToUChars(asciiIn[i],buf+4, (int32_t)(strlen(asciiIn[i])+1)); 797 u_strcat(buf,com); 798 799 // for every entry in unicodeIn array 800 // prepend www. and append .com 801 source.truncate(4); 802 source.append(unicodeIn[i]); 803 source.append(com); 804 source.append((UChar)0x0000); 805 // a) compare it with itself 806 const UChar* src = source.getBuffer(); 807 int32_t srcLen = u_strlen(src); //subtract null 808 809 testCompare(src,srcLen,src,srcLen,testName, func, TRUE); 810 811 // b) compare it with asciiIn equivalent 812 testCompare(src,srcLen,buf,u_strlen(buf),testName, func,TRUE); 813 814 // c) compare it with unicodeIn not equivalent 815 if(i==0){ 816 testCompare(src,srcLen,uni1.getBuffer(),uni1.length()-1,testName, func,FALSE); 817 }else{ 818 testCompare(src,srcLen,uni0.getBuffer(),uni0.length()-1,testName, func,FALSE); 819 } 820 // d) compare it with asciiIn not equivalent 821 if(i==0){ 822 testCompare(src,srcLen,ascii1.getBuffer(),ascii1.length()-1,testName, func,FALSE); 823 }else{ 824 testCompare(src,srcLen,ascii0.getBuffer(),ascii0.length()-1,testName, func,FALSE); 825 } 826 827 } 828} 829 830#if 0 831 832static int32_t 833getNextSeperator(UChar *src,int32_t srcLength, 834 UChar **limit){ 835 if(srcLength == -1){ 836 int32_t i; 837 for(i=0 ; ;i++){ 838 if(src[i] == 0){ 839 *limit = src + i; // point to null 840 return i; 841 } 842 if(src[i]==0x002e){ 843 *limit = src + (i+1); // go past the delimiter 844 return i; 845 } 846 } 847 // we have not found the delimiter 848 if(i==srcLength){ 849 *limit = src+srcLength; 850 } 851 return i; 852 }else{ 853 int32_t i; 854 for(i=0;i<srcLength;i++){ 855 if(src[i]==0x002e){ 856 *limit = src + (i+1); // go past the delimiter 857 return i; 858 } 859 } 860 // we have not found the delimiter 861 if(i==srcLength){ 862 *limit = src+srcLength; 863 } 864 return i; 865 } 866} 867 868void printPunycodeOutput(){ 869 870 UChar dest[MAX_DEST_SIZE]; 871 int32_t destCapacity=MAX_DEST_SIZE; 872 UChar* start; 873 UChar* limit; 874 int32_t labelLen=0; 875 UBool caseFlags[MAX_DEST_SIZE]; 876 877 for(int32_t i=0;i< sizeof(errorCases)/sizeof(errorCases[0]);i++){ 878 ErrorCases errorCase = errorCases[i]; 879 UErrorCode status = U_ZERO_ERROR; 880 start = errorCase.unicode; 881 int32_t srcLen = u_strlen(start); 882 labelLen = getNextSeperator(start,srcLen,&limit); 883 start = limit; 884 labelLen=getNextSeperator(start,srcLen-labelLen,&limit); 885 int32_t destLen = u_strToPunycode(dest,destCapacity,start,labelLen,caseFlags, &status); 886 if(U_FAILURE(status)){ 887 printf("u_strToPunycode failed for index %i\n",i); 888 continue; 889 } 890 for(int32_t j=0; j<destLen; j++){ 891 printf("%c",(char)dest[j]); 892 } 893 printf("\n"); 894 } 895} 896#endif 897 898void TestIDNA::testErrorCases(const char* IDNToASCIIName, TestFunc IDNToASCII, 899 const char* IDNToUnicodeName, TestFunc IDNToUnicode){ 900 UChar buf[MAX_DEST_SIZE]; 901 int32_t bufLen=0; 902 903 for(int32_t i=0;i< (int32_t)(sizeof(errorCases)/sizeof(errorCases[0]));i++){ 904 ErrorCases errorCase = errorCases[i]; 905 UChar* src =NULL; 906 if(errorCase.ascii != NULL){ 907 bufLen = (int32_t)strlen(errorCase.ascii); 908 u_charsToUChars(errorCase.ascii,buf, bufLen+1); 909 }else{ 910 bufLen = 1 ; 911 memset(buf,0,U_SIZEOF_UCHAR*MAX_DEST_SIZE); 912 } 913 914 if(errorCase.unicode[0]!=0){ 915 src = errorCase.unicode; 916 } 917 // test toASCII 918 testAPI(src,buf, 919 IDNToASCIIName, errorCase.useSTD3ASCIIRules, 920 errorCase.expected, TRUE, TRUE, IDNToASCII); 921 if(errorCase.testLabel ==TRUE){ 922 testAPI(src,buf, 923 IDNToASCIIName, errorCase.useSTD3ASCIIRules, 924 errorCase.expected, FALSE,TRUE, IDNToASCII); 925 } 926 if(errorCase.testToUnicode ==TRUE){ 927 testAPI((src==NULL)? NULL : buf,src, 928 IDNToUnicodeName, errorCase.useSTD3ASCIIRules, 929 errorCase.expected, TRUE, TRUE, IDNToUnicode); 930 } 931 932 } 933 934} 935/* 936void TestIDNA::testConformance(const char* toASCIIName, TestFunc toASCII, 937 const char* IDNToASCIIName, TestFunc IDNToASCII, 938 const char* IDNToUnicodeName, TestFunc IDNToUnicode, 939 const char* toUnicodeName, TestFunc toUnicode){ 940 UChar src[MAX_DEST_SIZE]; 941 int32_t srcLen=0; 942 UChar expected[MAX_DEST_SIZE]; 943 int32_t expectedLen = 0; 944 for(int32_t i=0;i< (int32_t)(sizeof(conformanceTestCases)/sizeof(conformanceTestCases[0]));i++){ 945 const char* utf8Chars1 = conformanceTestCases[i].in; 946 int32_t utf8Chars1Len = (int32_t)strlen(utf8Chars1); 947 const char* utf8Chars2 = conformanceTestCases[i].out; 948 int32_t utf8Chars2Len = (utf8Chars2 == NULL) ? 0 : (int32_t)strlen(utf8Chars2); 949 950 UErrorCode status = U_ZERO_ERROR; 951 u_strFromUTF8(src,MAX_DEST_SIZE,&srcLen,utf8Chars1,utf8Chars1Len,&status); 952 if(U_FAILURE(status)){ 953 errln(UnicodeString("Conversion of UTF8 source in conformanceTestCases[") + i +UnicodeString( "].in ( ")+prettify(utf8Chars1) +UnicodeString(" ) failed. Error: ")+ UnicodeString(u_errorName(status))); 954 continue; 955 } 956 if(utf8Chars2 != NULL){ 957 u_strFromUTF8(expected,MAX_DEST_SIZE,&expectedLen,utf8Chars2,utf8Chars2Len, &status); 958 if(U_FAILURE(status)){ 959 errln(UnicodeString("Conversion of UTF8 source in conformanceTestCases[") + i +UnicodeString( "].in ( ")+prettify(utf8Chars1) +UnicodeString(" ) failed. Error: ")+ UnicodeString(u_errorName(status))); 960 continue; 961 } 962 } 963 964 if(conformanceTestCases[i].expectedStatus != U_ZERO_ERROR){ 965 // test toASCII 966 testAPI(src,expected, 967 IDNToASCIIName, FALSE, 968 conformanceTestCases[i].expectedStatus, 969 TRUE, 970 (conformanceTestCases[i].expectedStatus != U_IDNA_UNASSIGNED_ERROR), 971 IDNToASCII); 972 973 testAPI(src,expected, 974 toASCIIName, FALSE, 975 conformanceTestCases[i].expectedStatus, TRUE, 976 (conformanceTestCases[i].expectedStatus != U_IDNA_UNASSIGNED_ERROR), 977 toASCII); 978 } 979 980 testAPI(src,src, 981 IDNToUnicodeName, FALSE, 982 conformanceTestCases[i].expectedStatus, TRUE, TRUE, IDNToUnicode); 983 testAPI(src,src, 984 toUnicodeName, FALSE, 985 conformanceTestCases[i].expectedStatus, TRUE, TRUE, toUnicode); 986 987 } 988 989} 990*/ 991// test and ascertain 992// func(func(func(src))) == func(src) 993void TestIDNA::testChaining(const UChar* src,int32_t numIterations,const char* testName, 994 UBool useSTD3ASCIIRules, UBool caseInsensitive, TestFunc func){ 995 UChar even[MAX_DEST_SIZE]; 996 UChar odd[MAX_DEST_SIZE]; 997 UChar expected[MAX_DEST_SIZE]; 998 int32_t i=0,evenLen=0,oddLen=0,expectedLen=0; 999 UErrorCode status = U_ZERO_ERROR; 1000 int32_t srcLen = u_strlen(src); 1001 int32_t options = (useSTD3ASCIIRules == TRUE) ? UIDNA_USE_STD3_RULES : UIDNA_DEFAULT; 1002 UParseError parseError; 1003 1004 // test null-terminated source 1005 expectedLen = func(src,-1,expected,MAX_DEST_SIZE, options, &parseError, &status); 1006 if(U_FAILURE(status)){ 1007 errcheckln(status, "%s null terminated source failed. Error: %s",testName, u_errorName(status)); 1008 } 1009 memcpy(odd,expected,(expectedLen+1) * U_SIZEOF_UCHAR); 1010 memcpy(even,expected,(expectedLen+1) * U_SIZEOF_UCHAR); 1011 for(;i<=numIterations; i++){ 1012 if((i%2) ==0){ 1013 evenLen = func(odd,-1,even,MAX_DEST_SIZE,options, &parseError, &status); 1014 if(U_FAILURE(status)){ 1015 errcheckln(status, "%s null terminated source failed - %s",testName, u_errorName(status)); 1016 break; 1017 } 1018 }else{ 1019 oddLen = func(even,-1,odd,MAX_DEST_SIZE,options, &parseError, &status); 1020 if(U_FAILURE(status)){ 1021 errln("%s null terminated source failed\n",testName); 1022 break; 1023 } 1024 } 1025 } 1026 if(caseInsensitive ==TRUE){ 1027 if( u_strCaseCompare(even,evenLen, expected,expectedLen, 0, &status) !=0 || 1028 u_strCaseCompare(odd,oddLen, expected,expectedLen, 0, &status) !=0 ){ 1029 1030 errln("Chaining for %s null terminated source failed\n",testName); 1031 } 1032 }else{ 1033 if( u_strncmp(even,expected,expectedLen) != 0 || 1034 u_strncmp(odd,expected,expectedLen) !=0 ){ 1035 1036 errln("Chaining for %s null terminated source failed\n",testName); 1037 } 1038 } 1039 1040 // test null-terminated source 1041 status = U_ZERO_ERROR; 1042 expectedLen = func(src,-1,expected,MAX_DEST_SIZE,options|UIDNA_ALLOW_UNASSIGNED, &parseError, &status); 1043 if(U_FAILURE(status)){ 1044 errcheckln(status, "%s null terminated source with options set failed. Error: %s",testName, u_errorName(status)); 1045 } 1046 memcpy(odd,expected,(expectedLen+1) * U_SIZEOF_UCHAR); 1047 memcpy(even,expected,(expectedLen+1) * U_SIZEOF_UCHAR); 1048 for(;i<=numIterations; i++){ 1049 if((i%2) ==0){ 1050 evenLen = func(odd,-1,even,MAX_DEST_SIZE,options|UIDNA_ALLOW_UNASSIGNED, &parseError, &status); 1051 if(U_FAILURE(status)){ 1052 errcheckln(status, "%s null terminated source with options set failed - %s",testName, u_errorName(status)); 1053 break; 1054 } 1055 }else{ 1056 oddLen = func(even,-1,odd,MAX_DEST_SIZE,options|UIDNA_ALLOW_UNASSIGNED, &parseError, &status); 1057 if(U_FAILURE(status)){ 1058 errln("%s null terminated source with options set failed\n",testName); 1059 break; 1060 } 1061 } 1062 } 1063 if(caseInsensitive ==TRUE){ 1064 if( u_strCaseCompare(even,evenLen, expected,expectedLen, 0, &status) !=0 || 1065 u_strCaseCompare(odd,oddLen, expected,expectedLen, 0, &status) !=0 ){ 1066 1067 errln("Chaining for %s null terminated source with options set failed\n",testName); 1068 } 1069 }else{ 1070 if( u_strncmp(even,expected,expectedLen) != 0 || 1071 u_strncmp(odd,expected,expectedLen) !=0 ){ 1072 1073 errln("Chaining for %s null terminated source with options set failed\n",testName); 1074 } 1075 } 1076 1077 1078 // test source with length 1079 status = U_ZERO_ERROR; 1080 expectedLen = func(src,srcLen,expected,MAX_DEST_SIZE,options, &parseError, &status); 1081 if(U_FAILURE(status)){ 1082 errcheckln(status, "%s null terminated source failed. Error: %s",testName, u_errorName(status)); 1083 } 1084 memcpy(odd,expected,(expectedLen+1) * U_SIZEOF_UCHAR); 1085 memcpy(even,expected,(expectedLen+1) * U_SIZEOF_UCHAR); 1086 for(;i<=numIterations; i++){ 1087 if((i%2) ==0){ 1088 evenLen = func(odd,oddLen,even,MAX_DEST_SIZE,options, &parseError, &status); 1089 if(U_FAILURE(status)){ 1090 errcheckln(status, "%s source with source length failed - %s",testName, u_errorName(status)); 1091 break; 1092 } 1093 }else{ 1094 oddLen = func(even,evenLen,odd,MAX_DEST_SIZE,options, &parseError, &status); 1095 if(U_FAILURE(status)){ 1096 errcheckln(status, "%s source with source length failed - %s",testName, u_errorName(status)); 1097 break; 1098 } 1099 } 1100 } 1101 if(caseInsensitive ==TRUE){ 1102 if( u_strCaseCompare(even,evenLen, expected,expectedLen, 0, &status) !=0 || 1103 u_strCaseCompare(odd,oddLen, expected,expectedLen, 0, &status) !=0 ){ 1104 1105 errln("Chaining for %s source with source length failed\n",testName); 1106 } 1107 }else{ 1108 if( u_strncmp(even,expected,expectedLen) != 0 || 1109 u_strncmp(odd,expected,expectedLen) !=0 ){ 1110 1111 errln("Chaining for %s source with source length failed\n",testName); 1112 } 1113 } 1114 status = U_ZERO_ERROR; 1115 expectedLen = func(src,srcLen,expected,MAX_DEST_SIZE,options|UIDNA_ALLOW_UNASSIGNED, &parseError, &status); 1116 if(U_FAILURE(status)){ 1117 errcheckln(status, "%s null terminated source with options set failed. Error: %s",testName, u_errorName(status)); 1118 } 1119 memcpy(odd,expected,(expectedLen+1) * U_SIZEOF_UCHAR); 1120 memcpy(even,expected,(expectedLen+1) * U_SIZEOF_UCHAR); 1121 for(;i<=numIterations; i++){ 1122 if((i%2) ==0){ 1123 evenLen = func(odd,oddLen,even,MAX_DEST_SIZE,options|UIDNA_ALLOW_UNASSIGNED, &parseError, &status); 1124 if(U_FAILURE(status)){ 1125 errcheckln(status, "%s source with source length and options set failed - %s",testName, u_errorName(status)); 1126 break; 1127 } 1128 }else{ 1129 oddLen = func(even,evenLen,odd,MAX_DEST_SIZE,options|UIDNA_ALLOW_UNASSIGNED, &parseError, &status); 1130 if(U_FAILURE(status)){ 1131 errcheckln(status, "%s source with source length and options set failed - %s",testName, u_errorName(status)); 1132 break; 1133 } 1134 } 1135 } 1136 if(caseInsensitive ==TRUE){ 1137 if( u_strCaseCompare(even,evenLen, expected,expectedLen, 0, &status) !=0 || 1138 u_strCaseCompare(odd,oddLen, expected,expectedLen, 0, &status) !=0 ){ 1139 1140 errln("Chaining for %s source with source length and options set failed\n",testName); 1141 } 1142 }else{ 1143 if( u_strncmp(even,expected,expectedLen) != 0 || 1144 u_strncmp(odd,expected,expectedLen) !=0 ){ 1145 1146 errln("Chaining for %s source with source length and options set failed\n",testName); 1147 } 1148 } 1149} 1150void TestIDNA::testChaining(const char* toASCIIName, TestFunc toASCII, 1151 const char* toUnicodeName, TestFunc toUnicode){ 1152 int32_t i; 1153 UChar buf[MAX_DEST_SIZE]; 1154 1155 for(i=0;i< (int32_t)(sizeof(asciiIn)/sizeof(asciiIn[0])); i++){ 1156 u_charsToUChars(asciiIn[i],buf, (int32_t)(strlen(asciiIn[i])+1)); 1157 testChaining(buf,5,toUnicodeName, FALSE, FALSE, toUnicode); 1158 } 1159 for(i=0;i< (int32_t)(sizeof(unicodeIn)/sizeof(unicodeIn[0])); i++){ 1160 testChaining(unicodeIn[i], 5,toASCIIName, FALSE, TRUE, toASCII); 1161 } 1162} 1163 1164 1165void TestIDNA::testRootLabelSeparator(const char* testName, CompareFunc func, 1166 const char* IDNToASCIIName, TestFunc IDNToASCII, 1167 const char* IDNToUnicodeName, TestFunc IDNToUnicode){ 1168 int32_t i; 1169 1170 1171 UChar www[] = {0x0057, 0x0057, 0x0057, 0x002E, 0x0000}; 1172 UChar com[] = {0x002E, 0x0043, 0x004F, 0x004D, 0x002E, /* root label separator */0x0000}; 1173 UChar buf[MAX_DEST_SIZE]={0x0057, 0x0057, 0x0057, 0x002E, 0x0000}; 1174 1175 UnicodeString source(www), uni0(www),uni1(www), ascii0(www), ascii1(www); 1176 1177 uni0.append(unicodeIn[0]); 1178 uni0.append(com); 1179 uni0.append((UChar)0x0000); 1180 1181 uni1.append(unicodeIn[1]); 1182 uni1.append(com); 1183 uni1.append((UChar)0x0000); 1184 1185 ascii0.append(asciiIn[0]); 1186 ascii0.append(com); 1187 ascii0.append((UChar)0x0000); 1188 1189 ascii1.append(asciiIn[1]); 1190 ascii1.append(com); 1191 ascii1.append((UChar)0x0000); 1192 1193 for(i=0;i< (int32_t)(sizeof(unicodeIn)/sizeof(unicodeIn[0])); i++){ 1194 1195 u_charsToUChars(asciiIn[i],buf+4, (int32_t)(strlen(asciiIn[i])+1)); 1196 u_strcat(buf,com); 1197 1198 // for every entry in unicodeIn array 1199 // prepend www. and append .com 1200 source.truncate(4); 1201 source.append(unicodeIn[i]); 1202 source.append(com); 1203 source.append((UChar)0x0000); 1204 1205 const UChar* src = source.getBuffer(); 1206 int32_t srcLen = u_strlen(src); //subtract null 1207 1208 // b) compare it with asciiIn equivalent 1209 testCompare(src,srcLen,buf,u_strlen(buf),testName, func,TRUE); 1210 1211 // a) compare it with itself 1212 testCompare(src,srcLen,src,srcLen,testName, func,TRUE); 1213 1214 1215 // IDNToASCII comparison 1216 testAPI(src,buf,IDNToASCIIName,FALSE,U_ZERO_ERROR,TRUE, TRUE, IDNToASCII); 1217 // IDNToUnicode comparison 1218 testAPI(buf,src,IDNToUnicodeName, FALSE,U_ZERO_ERROR, TRUE, TRUE, IDNToUnicode); 1219 1220 // c) compare it with unicodeIn not equivalent 1221 if(i==0){ 1222 testCompare(src,srcLen,uni1.getBuffer(),uni1.length()-1,testName, func,FALSE); 1223 }else{ 1224 testCompare(src,srcLen,uni0.getBuffer(),uni0.length()-1,testName, func,FALSE); 1225 } 1226 // d) compare it with asciiIn not equivalent 1227 if(i==0){ 1228 testCompare(src,srcLen,ascii1.getBuffer(),ascii1.length()-1,testName, func,FALSE); 1229 }else{ 1230 testCompare(src,srcLen,ascii0.getBuffer(),ascii0.length()-1,testName, func,FALSE); 1231 } 1232 } 1233} 1234 1235//--------------------------------------------- 1236// runIndexedTest 1237//--------------------------------------------- 1238 1239extern IntlTest *createUTS46Test(); 1240 1241void TestIDNA::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par) 1242{ 1243 if (exec) logln((UnicodeString)"TestSuite IDNA API "); 1244 switch (index) { 1245 1246 case 0: name = "TestToASCII"; if (exec) TestToASCII(); break; 1247 case 1: name = "TestToUnicode"; if (exec) TestToUnicode(); break; 1248 case 2: name = "TestIDNToASCII"; if (exec) TestIDNToASCII(); break; 1249 case 3: name = "TestIDNToUnicode"; if (exec) TestIDNToUnicode(); break; 1250 case 4: name = "TestCompare"; if (exec) TestCompare(); break; 1251 case 5: name = "TestErrorCases"; if (exec) TestErrorCases(); break; 1252 case 6: name = "TestChaining"; if (exec) TestChaining(); break; 1253 case 7: name = "TestRootLabelSeparator"; if(exec) TestRootLabelSeparator(); break; 1254 case 8: name = "TestCompareReferenceImpl"; if(exec) TestCompareReferenceImpl(); break; 1255 case 9: name = "TestDataFile"; if(exec) TestDataFile(); break; 1256#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION 1257 case 10: name = "TestRefIDNA"; if(exec) TestRefIDNA(); break; 1258 case 11: name = "TestIDNAMonkeyTest"; if(exec) TestIDNAMonkeyTest(); break; 1259#else 1260 case 10: case 11: name = "skip"; break; 1261#endif 1262 case 12: 1263 { 1264 name = "TestConformanceTestVectors"; 1265 if(exec){ 1266 logln("TestSuite IDNA conf----"); logln(); 1267 IdnaConfTest test; 1268 callTest(test, par); 1269 } 1270 break; 1271 } 1272 case 13: 1273 name = "UTS46Test"; 1274 if (exec) { 1275 logln("TestSuite UTS46Test---"); logln(); 1276 LocalPointer<IntlTest> test(createUTS46Test()); 1277 callTest(*test, par); 1278 } 1279 break; 1280 default: name = ""; break; /*needed to end loop*/ 1281 } 1282} 1283void TestIDNA::TestToASCII(){ 1284 testToASCII("uidna_toASCII", uidna_toASCII); 1285} 1286void TestIDNA::TestToUnicode(){ 1287 testToUnicode("uidna_toUnicode", uidna_toUnicode); 1288} 1289void TestIDNA::TestIDNToASCII(){ 1290 testIDNToASCII("uidna_IDNToASCII", uidna_IDNToASCII); 1291} 1292void TestIDNA::TestIDNToUnicode(){ 1293 testIDNToUnicode("uidna_IDNToUnicode", uidna_IDNToUnicode); 1294} 1295void TestIDNA::TestCompare(){ 1296 testCompare("uidna_compare",uidna_compare); 1297} 1298void TestIDNA::TestErrorCases(){ 1299 testErrorCases( "uidna_IDNToASCII",uidna_IDNToASCII, 1300 "uidna_IDNToUnicode",uidna_IDNToUnicode); 1301} 1302void TestIDNA::TestRootLabelSeparator(){ 1303 testRootLabelSeparator( "uidna_compare",uidna_compare, 1304 "uidna_IDNToASCII", uidna_IDNToASCII, 1305 "uidna_IDNToUnicode",uidna_IDNToUnicode 1306 ); 1307} 1308void TestIDNA::TestChaining(){ 1309 testChaining("uidna_toASCII",uidna_toASCII, "uidna_toUnicode", uidna_toUnicode); 1310} 1311 1312 1313static const int loopCount = 100; 1314static const int maxCharCount = 20; 1315static const int maxCodePoint = 0x10ffff; 1316static uint32_t 1317randul() 1318{ 1319 static UBool initialized = FALSE; 1320 if (!initialized) 1321 { 1322 srand((unsigned)time(NULL)); 1323 initialized = TRUE; 1324 } 1325 // Assume rand has at least 12 bits of precision 1326 uint32_t l = 0; 1327 for (uint32_t i=0; i<sizeof(l); ++i) 1328 ((char*)&l)[i] = (char)((rand() & 0x0FF0) >> 4); 1329 return l; 1330} 1331 1332/** 1333 * Return a random integer i where 0 <= i < n. 1334 * A special function that gets random codepoints from planes 0,1,2 and 14 1335 */ 1336static int32_t rand_uni() 1337{ 1338 int32_t retVal = (int32_t)(randul()& 0x3FFFF); 1339 if(retVal >= 0x30000){ 1340 retVal+=0xB0000; 1341 } 1342 return retVal; 1343} 1344 1345static int32_t randi(int32_t n){ 1346 return (int32_t) (randul() % (n+1)); 1347} 1348 1349void getTestSource(UnicodeString& fillIn) { 1350 int32_t i = 0; 1351 int32_t charCount = (randi(maxCharCount) + 1); 1352 while (i <charCount ) { 1353 int32_t codepoint = rand_uni(); 1354 if(codepoint == 0x0000){ 1355 continue; 1356 } 1357 fillIn.append((UChar32)codepoint); 1358 i++; 1359 } 1360 1361} 1362 1363UnicodeString TestIDNA::testCompareReferenceImpl(UnicodeString& src, 1364 TestFunc refIDNA, const char* refIDNAName, 1365 TestFunc uIDNA, const char* uIDNAName, 1366 int32_t options){ 1367 1368 const UChar* srcUChars = src.getBuffer(); 1369 UChar exp[MAX_DEST_SIZE]={0}; 1370 int32_t expCap = MAX_DEST_SIZE, expLen=0; 1371 UErrorCode expStatus = U_ZERO_ERROR; 1372 UParseError parseError; 1373 1374 logln("Comparing "+ UnicodeString(refIDNAName) 1375 + " with "+ UnicodeString(uIDNAName) 1376 +" for input: " + prettify(srcUChars)); 1377 1378 expLen = refIDNA(srcUChars, src.length()-1, exp, expCap, 1379 options, &parseError, &expStatus); 1380 1381 UChar got[MAX_DEST_SIZE]={0}; 1382 int32_t gotCap = MAX_DEST_SIZE, gotLen=0; 1383 UErrorCode gotStatus = U_ZERO_ERROR; 1384 1385 gotLen = uIDNA(srcUChars, src.length()-1, got, gotCap, 1386 options, &parseError, &gotStatus); 1387 1388 if(expStatus != gotStatus){ 1389 errln("Did not get the expected status while comparing " + UnicodeString(refIDNAName) 1390 + " with " + UnicodeString(uIDNAName) 1391 + " Expected: " + UnicodeString(u_errorName(expStatus)) 1392 + " Got: " + UnicodeString(u_errorName(gotStatus)) 1393 + " for Source: "+ prettify(srcUChars) 1394 + " Options: " + options); 1395 return UnicodeString(""); 1396 } 1397 1398 // now we know that both implementations yielded same error 1399 if(U_SUCCESS(expStatus)){ 1400 // compare the outputs if status == U_ZERO_ERROR 1401 if(u_strCompare(exp, expLen, got, gotLen, TRUE) != 0){ 1402 errln("Did not get the expected output while comparing " + UnicodeString(refIDNAName) 1403 + " with " + UnicodeString(uIDNAName) 1404 + " Expected: " + prettify(UnicodeString(exp, expLen)) 1405 + " Got: " + prettify(UnicodeString(got, gotLen)) 1406 + " for Source: "+ prettify(srcUChars) 1407 + " Options: " + options); 1408 } 1409 return UnicodeString(exp, expLen); 1410 1411 }else{ 1412 logln("Got the same error while comparing " 1413 + UnicodeString(refIDNAName) 1414 + " with "+ UnicodeString(uIDNAName) 1415 +" for input: " + prettify(srcUChars)); 1416 } 1417 return UnicodeString(""); 1418} 1419 1420void TestIDNA::testCompareReferenceImpl(const UChar* src, int32_t srcLen){ 1421 UnicodeString label(src,srcLen); 1422 label.append((UChar)0x0000); 1423 1424 //test idnaref_toASCII and idnare 1425 UnicodeString asciiLabel = testCompareReferenceImpl(label, 1426 idnaref_toASCII, "idnaref_toASCII", 1427 uidna_toASCII, "uidna_toASCII", 1428 UIDNA_ALLOW_UNASSIGNED); 1429 testCompareReferenceImpl(label, 1430 idnaref_toASCII, "idnaref_toASCII", 1431 uidna_toASCII, "uidna_toASCII", 1432 UIDNA_DEFAULT); 1433 testCompareReferenceImpl(label, 1434 idnaref_toASCII, "idnaref_toASCII", 1435 uidna_toASCII, "uidna_toASCII", 1436 UIDNA_USE_STD3_RULES); 1437 testCompareReferenceImpl(label, 1438 idnaref_toASCII, "idnaref_toASCII", 1439 uidna_toASCII, "uidna_toASCII", 1440 UIDNA_USE_STD3_RULES | UIDNA_ALLOW_UNASSIGNED); 1441 1442 if(asciiLabel.length()!=0){ 1443 asciiLabel.append((UChar)0x0000); 1444 1445 // test toUnciode 1446 testCompareReferenceImpl(asciiLabel, 1447 idnaref_toUnicode, "idnaref_toUnicode", 1448 uidna_toUnicode, "uidna_toUnicode", 1449 UIDNA_ALLOW_UNASSIGNED); 1450 testCompareReferenceImpl(asciiLabel, 1451 idnaref_toUnicode, "idnaref_toUnicode", 1452 uidna_toUnicode, "uidna_toUnicode", 1453 UIDNA_DEFAULT); 1454 testCompareReferenceImpl(asciiLabel, 1455 idnaref_toUnicode, "idnaref_toUnicode", 1456 uidna_toUnicode, "uidna_toUnicode", 1457 UIDNA_USE_STD3_RULES); 1458 testCompareReferenceImpl(asciiLabel, 1459 idnaref_toUnicode, "idnaref_toUnicode", 1460 uidna_toUnicode, "uidna_toUnicode", 1461 UIDNA_USE_STD3_RULES | UIDNA_ALLOW_UNASSIGNED); 1462 } 1463 1464} 1465const char* failures[] ={ 1466 "\\uAA42\\U0001F8DD\\U00019D01\\U000149A3\\uD385\\U000EE0F5\\U00018B92\\U000179D1\\U00018624\\U0002227F\\U000E83C0\\U000E8DCD\\u5460\\U00017F34\\U0001570B\\u43D1\\U0002C9C9\\U000281EC\\u2105\\U000180AE\\uC5D4", 1467 "\\U0002F5A6\\uD638\\u0D0A\\u9E9C\\uFE5B\\U0001FCCB\\u66C4", 1468}; 1469 1470void TestIDNA::TestIDNAMonkeyTest(){ 1471 UnicodeString source; 1472 UErrorCode status = U_ZERO_ERROR; 1473 int i; 1474 1475 getInstance(status); // Init prep 1476 if (U_FAILURE(status)) { 1477 dataerrln("Test could not initialize. Got %s", u_errorName(status)); 1478 return; 1479 } 1480 1481 for(i=0; i<loopCount; i++){ 1482 source.truncate(0); 1483 getTestSource(source); 1484 source.append((UChar)0x0000); 1485 const UChar* src = source.getBuffer(); 1486 testCompareReferenceImpl(src,source.length()-1); 1487 testCompareReferenceImpl(src,source.length()-1); 1488 } 1489 1490 /* for debugging */ 1491 for (i=0; i<(int)(sizeof(failures)/sizeof(failures[0])); i++){ 1492 source.truncate(0); 1493 source.append( UnicodeString(failures[i], -1, US_INV) ); 1494 source = source.unescape(); 1495 source.append((UChar)0x0000); 1496 const UChar *src = source.getBuffer(); 1497 testCompareReferenceImpl(src,source.length()-1); 1498 //debug(source.getBuffer(),source.length(),UIDNA_ALLOW_UNASSIGNED); 1499 } 1500 1501 1502 source.truncate(0); 1503 source.append(UNICODE_STRING_SIMPLE("\\uCF18\\U00021161\\U000EEF11\\U0002BB82\\U0001D63C")); 1504 debug(source.getBuffer(),source.length(),UIDNA_ALLOW_UNASSIGNED); 1505 1506 { // test deletion of code points 1507 UnicodeString source("\\u043f\\u00AD\\u034f\\u043e\\u0447\\u0435\\u043c\\u0443\\u0436\\u0435\\u043e\\u043d\\u0438\\u043d\\u0435\\u0433\\u043e\\u0432\\u043e\\u0440\\u044f\\u0442\\u043f\\u043e\\u0440\\u0443\\u0441\\u0441\\u043a\\u0438\\u0000", -1, US_INV); 1508 source = source.unescape(); 1509 UnicodeString expected("\\u043f\\u043e\\u0447\\u0435\\u043c\\u0443\\u0436\\u0435\\u043e\\u043d\\u0438\\u043d\\u0435\\u0433\\u043e\\u0432\\u043e\\u0440\\u044f\\u0442\\u043f\\u043e\\u0440\\u0443\\u0441\\u0441\\u043a\\u0438\\u0000", -1, US_INV); 1510 expected = expected.unescape(); 1511 UnicodeString ascii("xn--b1abfaaepdrnnbgefbadotcwatmq2g4l"); 1512 ascii.append((UChar)0x0000); 1513 testAPI(source.getBuffer(),ascii.getBuffer(), "uidna_toASCII", FALSE, U_ZERO_ERROR, TRUE, TRUE, uidna_toASCII); 1514 1515 testAPI(source.getBuffer(),ascii.getBuffer(), "idnaref_toASCII", FALSE, U_ZERO_ERROR, TRUE, TRUE, idnaref_toASCII); 1516 1517 testCompareReferenceImpl(source.getBuffer(), source.length()-1); 1518 } 1519 1520} 1521 1522void TestIDNA::TestCompareReferenceImpl(){ 1523 1524 UChar src [2] = {0,0}; 1525 int32_t srcLen = 0; 1526 1527 // data even OK? 1528 { 1529 UErrorCode dataStatus = U_ZERO_ERROR; 1530 loadTestData(dataStatus); 1531 if(U_FAILURE(dataStatus)) { 1532 dataerrln("Couldn't load test data: %s\n", u_errorName(dataStatus)); // save us from thousands and thousands of errors 1533 return; 1534 } 1535 } 1536 1537 for (int32_t i = 0; i <= 0x10FFFF; i++){ 1538 if (quick == TRUE && i > 0x0FFF){ 1539 return; 1540 } 1541 if(i == 0x30000){ 1542 // jump to E0000, no characters assigned in plain 3 to plain 13 as of Unicode 6.0 1543 i = 0xE0000; 1544 } 1545 if (i > 0xFFFF){ 1546 src[0] = U16_LEAD(i); 1547 src[1] = U16_TRAIL(i); 1548 srcLen =2; 1549 } else { 1550 src[0] = (UChar)i; 1551 src[1] = 0; 1552 srcLen = 1; 1553 } 1554 testCompareReferenceImpl(src, srcLen); 1555 } 1556} 1557 1558void TestIDNA::TestRefIDNA(){ 1559 UErrorCode status = U_ZERO_ERROR; 1560 getInstance(status); // Init prep 1561 if (U_FAILURE(status)) { 1562 if (status == U_FILE_ACCESS_ERROR) { 1563 dataerrln("Test could not initialize. Got %s", u_errorName(status)); 1564 } 1565 return; 1566 } 1567 1568 testToASCII("idnaref_toASCII", idnaref_toASCII); 1569 testToUnicode("idnaref_toUnicode", idnaref_toUnicode); 1570 testIDNToASCII("idnaref_IDNToASCII", idnaref_IDNToASCII); 1571 testIDNToUnicode("idnaref_IDNToUnicode", idnaref_IDNToUnicode); 1572 testCompare("idnaref_compare",idnaref_compare); 1573 testErrorCases( "idnaref_IDNToASCII",idnaref_IDNToASCII, 1574 "idnaref_IDNToUnicode",idnaref_IDNToUnicode); 1575 testChaining("idnaref_toASCII",idnaref_toASCII, "idnaref_toUnicode", idnaref_toUnicode); 1576 1577 testRootLabelSeparator( "idnaref_compare",idnaref_compare, 1578 "idnaref_IDNToASCII", idnaref_IDNToASCII, 1579 "idnaref_IDNToUnicode",idnaref_IDNToUnicode 1580 ); 1581 testChaining("idnaref_toASCII",idnaref_toASCII, "idnaref_toUnicode", idnaref_toUnicode); 1582} 1583 1584 1585void TestIDNA::TestDataFile(){ 1586 testData(*this); 1587} 1588TestIDNA::~TestIDNA(){ 1589 if(gPrep!=NULL){ 1590 delete gPrep; 1591 gPrep = NULL; 1592 } 1593} 1594 1595NamePrepTransform* TestIDNA::gPrep = NULL; 1596 1597NamePrepTransform* TestIDNA::getInstance(UErrorCode& status){ 1598 if(TestIDNA::gPrep == NULL){ 1599 UParseError parseError; 1600 TestIDNA::gPrep = NamePrepTransform::createInstance(parseError, status); 1601 if(TestIDNA::gPrep ==NULL){ 1602 //status = U_MEMORY_ALLOCATION_ERROR; 1603 return NULL; 1604 } 1605 } 1606 return TestIDNA::gPrep; 1607 1608} 1609#endif /* #if !UCONFIG_NO_IDNA */ 1610