icuSources/test/cintltst/idnatest.c

   1 /*
   2  *******************************************************************************
   3  *
   4  *   Copyright (C) 2003-2007, 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
  31 static void TestToUnicode(void);
  32 static void TestToASCII(void);
  33 static void TestIDNToUnicode(void);
  34 static void TestIDNToASCII(void);
  35 static void TestCompare(void);
  36 static void TestUnicode32Norm(void);
  37 static void TestJB4490(void);
  38 static void TestJB4475(void);
  39 static void TestLength(void);
  40
  41 void addIDNATest(TestNode** root);
  42
  43
  44 typedef int32_t
  45 (U_EXPORT2 *TestFunc) (   const UChar *src, int32_t srcLength,
  46                 UChar *dest, int32_t destCapacity,
  47                 int32_t options, UParseError *parseError,
  48                 UErrorCode *status);
  49 typedef int32_t
  50 (U_EXPORT2 *CompareFunc) (const UChar *s1, int32_t s1Len,
  51                 const UChar *s2, int32_t s2Len,
  52                 int32_t options,
  53                 UErrorCode *status);
  54
  55
  56 void
  57 addIDNATest(TestNode** root)
  58 {
  59    addTest(root, &TestToUnicode,    "idna/TestToUnicode");
  60    addTest(root, &TestToASCII,      "idna/TestToASCII");
  61    addTest(root, &TestIDNToUnicode, "idna/TestIDNToUnicode");
  62    addTest(root, &TestIDNToASCII,   "idna/TestIDNToASCII");
  63    addTest(root, &TestCompare,      "idna/TestCompare");
  64    addTest(root, &TestUnicode32Norm,"idna/TestUnicode32Norm");
  65    addTest(root, &TestJB4490,        "idna/TestJB4490");
  66    addTest(root, &TestJB4475,       "idna/TestJB4475");
  67    addTest(root, &TestLength,       "idna/TestLength");
  68 }
  69
  70 static void
  71 testAPI(const UChar* src, const UChar* expected, const char* testName,
  72             UBool useSTD3ASCIIRules,UErrorCode expectedStatus,
  73             UBool doCompare, UBool testUnassigned,  TestFunc func){
  74
  75     UErrorCode status = U_ZERO_ERROR;
  76     UChar destStack[MAX_DEST_SIZE];
  77     int32_t destLen = 0;
  78     UChar* dest = NULL;
  79     int32_t expectedLen = (expected != NULL) ? u_strlen(expected) : 0;
  80     int32_t options = (useSTD3ASCIIRules == TRUE) ? UIDNA_USE_STD3_RULES : UIDNA_DEFAULT;
  81     UParseError parseError;
  82     int32_t tSrcLen = 0;
  83     UChar* tSrc = NULL;
  84
  85     if(src != NULL){
  86         tSrcLen = u_strlen(src);
  87         tSrc  =(UChar*) malloc( U_SIZEOF_UCHAR * tSrcLen );
  88         memcpy(tSrc,src,tSrcLen * U_SIZEOF_UCHAR);
  89     }
  90
  91     /* test null-terminated source and return value of number of UChars required */
  92
  93     destLen = func(src,-1,NULL,0,options, &parseError , &status);
  94     if(status == U_BUFFER_OVERFLOW_ERROR){
  95         status = U_ZERO_ERROR; /* reset error code */
  96         if(destLen+1 < MAX_DEST_SIZE){
  97             dest = destStack;
  98             destLen = func(src,-1,dest,destLen+1,options, &parseError, &status);
  99             /* TODO : compare output with expected */
 100             if(U_SUCCESS(status) && expectedStatus != U_IDNA_STD3_ASCII_RULES_ERROR&& (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){
 101                 log_err("Did not get the expected result for  null terminated source.\n" );
 102             }
 103         }else{
 104             log_err( "%s null terminated source failed. Requires destCapacity > 300\n",testName);
 105         }
 106     }
 107
 108     if(status != expectedStatus){
 109         log_err( "Did not get the expected error for %s null terminated source failed. Expected: %s Got: %s\n",testName, u_errorName(expectedStatus), u_errorName(status));
 110         free(tSrc);
 111         return;
 112     }
 113     if(testUnassigned ){
 114         status = U_ZERO_ERROR;
 115         destLen = func(src,-1,NULL,0,options | UIDNA_ALLOW_UNASSIGNED, &parseError, &status);
 116         if(status == U_BUFFER_OVERFLOW_ERROR){
 117             status = U_ZERO_ERROR; /* reset error code */
 118             if(destLen+1 < MAX_DEST_SIZE){
 119                 dest = destStack;
 120                 destLen = func(src,-1,dest,destLen+1,options | UIDNA_ALLOW_UNASSIGNED, &parseError, &status);
 121                 /* TODO : compare output with expected */
 122                 if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){
 123                     log_err("Did not get the expected result for %s null terminated source with both options set.\n",testName);
 124
 125                 }
 126             }else{
 127                 log_err( "%s null terminated source failed. Requires destCapacity > 300\n",testName);
 128             }
 129         }
 130         /*testing query string*/
 131         if(status != expectedStatus && expectedStatus != U_IDNA_UNASSIGNED_ERROR){
 132             log_err( "Did not get the expected error for %s null terminated source with options set. Expected: %s Got: %s\n",testName, u_errorName(expectedStatus), u_errorName(status));
 133         }
 134     }
 135
 136     status = U_ZERO_ERROR;
 137
 138     /* test source with lengthand return value of number of UChars required*/
 139     destLen = func(tSrc, tSrcLen, NULL,0,options, &parseError, &status);
 140     if(status == U_BUFFER_OVERFLOW_ERROR){
 141         status = U_ZERO_ERROR; /* reset error code */
 142         if(destLen+1 < MAX_DEST_SIZE){
 143             dest = destStack;
 144             destLen = func(src,u_strlen(src),dest,destLen+1,options, &parseError, &status);
 145             /* TODO : compare output with expected */
 146             if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){
 147                 log_err("Did not get the expected result for %s with source length.\n",testName);
 148             }
 149         }else{
 150             log_err( "%s with source length  failed. Requires destCapacity > 300\n",testName);
 151         }
 152     }
 153
 154     if(status != expectedStatus){
 155         log_err( "Did not get the expected error for %s with source length. Expected: %s Got: %s\n",testName, u_errorName(expectedStatus), u_errorName(status));
 156     }
 157     if(testUnassigned){
 158         status = U_ZERO_ERROR;
 159
 160         destLen = func(tSrc,tSrcLen,NULL,0,options | UIDNA_ALLOW_UNASSIGNED, &parseError, &status);
 161
 162         if(status == U_BUFFER_OVERFLOW_ERROR){
 163             status = U_ZERO_ERROR; /* reset error code */
 164             if(destLen+1 < MAX_DEST_SIZE){
 165                 dest = destStack;
 166                 destLen = func(src,u_strlen(src),dest,destLen+1,options | UIDNA_ALLOW_UNASSIGNED, &parseError, &status);
 167                 /* TODO : compare output with expected */
 168                 if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){
 169                     log_err("Did not get the expected result for %s with source length and both options set.\n",testName);
 170                 }
 171             }else{
 172                 log_err( "%s with source length  failed. Requires destCapacity > 300\n",testName);
 173             }
 174         }
 175         /*testing query string*/
 176         if(status != expectedStatus && expectedStatus != U_IDNA_UNASSIGNED_ERROR){
 177             log_err( "Did not get the expected error for %s with source length and options set. Expected: %s Got: %s\n",testName, u_errorName(expectedStatus), u_errorName(status));
 178         }
 179     }
 180
 181     status = U_ZERO_ERROR;
 182     destLen = func(src,-1,NULL,0,options | UIDNA_USE_STD3_RULES, &parseError, &status);
 183     if(status == U_BUFFER_OVERFLOW_ERROR){
 184         status = U_ZERO_ERROR; /* reset error code*/
 185         if(destLen+1 < MAX_DEST_SIZE){
 186             dest = destStack;
 187             destLen = func(src,-1,dest,destLen+1,options | UIDNA_USE_STD3_RULES, &parseError, &status);
 188             /* TODO : compare output with expected*/
 189             if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){
 190                 log_err("Did not get the expected result for %s null terminated source with both options set.\n",testName);
 191
 192             }
 193         }else{
 194             log_err( "%s null terminated source failed. Requires destCapacity > 300\n",testName);
 195         }
 196     }
 197     /*testing query string*/
 198     if(status != expectedStatus){
 199         log_err( "Did not get the expected error for %s null terminated source with options set. Expected: %s Got: %s\n",testName, u_errorName(expectedStatus), u_errorName(status));
 200     }
 201
 202     status = U_ZERO_ERROR;
 203
 204     destLen = func(tSrc,tSrcLen,NULL,0,options | UIDNA_USE_STD3_RULES, &parseError, &status);
 205
 206     if(status == U_BUFFER_OVERFLOW_ERROR){
 207         status = U_ZERO_ERROR; /* reset error code*/
 208         if(destLen+1 < MAX_DEST_SIZE){
 209             dest = destStack;
 210             destLen = func(src,u_strlen(src),dest,destLen+1,options | UIDNA_USE_STD3_RULES, &parseError, &status);
 211             /* TODO : compare output with expected*/
 212             if(U_SUCCESS(status) && (doCompare==TRUE) && u_strCaseCompare(dest,destLen, expected,expectedLen,0,&status)!=0){
 213                 log_err("Did not get the expected result for %s with source length and both options set.\n",testName);
 214             }
 215         }else{
 216             log_err( "%s with source length  failed. Requires destCapacity > 300\n",testName);
 217         }
 218     }
 219     /*testing query string*/
 220     if(status != expectedStatus && expectedStatus != U_IDNA_UNASSIGNED_ERROR){
 221         log_err( "Did not get the expected error for %s with source length and options set. Expected: %s Got: %s\n",testName, u_errorName(expectedStatus), u_errorName(status));
 222     }
 223     free(tSrc);
 224 }
 225
 226 static UChar unicodeIn[][41] ={
 227     {
 228         0x0644, 0x064A, 0x0647, 0x0645, 0x0627, 0x0628, 0x062A, 0x0643, 0x0644,
 229         0x0645, 0x0648, 0x0634, 0x0639, 0x0631, 0x0628, 0x064A, 0x061F, 0x0000
 230     },
 231     {
 232         0x4ED6, 0x4EEC, 0x4E3A, 0x4EC0, 0x4E48, 0x4E0D, 0x8BF4, 0x4E2D, 0x6587,
 233         0x0000
 234     },
 235     {
 236         0x0050, 0x0072, 0x006F, 0x010D, 0x0070, 0x0072, 0x006F, 0x0073, 0x0074,
 237         0x011B, 0x006E, 0x0065, 0x006D, 0x006C, 0x0075, 0x0076, 0x00ED, 0x010D,
 238         0x0065, 0x0073, 0x006B, 0x0079, 0x0000
 239     },
 240     {
 241         0x05DC, 0x05DE, 0x05D4, 0x05D4, 0x05DD, 0x05E4, 0x05E9, 0x05D5, 0x05D8,
 242         0x05DC, 0x05D0, 0x05DE, 0x05D3, 0x05D1, 0x05E8, 0x05D9, 0x05DD, 0x05E2,
 243         0x05D1, 0x05E8, 0x05D9, 0x05EA, 0x0000
 244     },
 245     {
 246         0x092F, 0x0939, 0x0932, 0x094B, 0x0917, 0x0939, 0x093F, 0x0928, 0x094D,
 247         0x0926, 0x0940, 0x0915, 0x094D, 0x092F, 0x094B, 0x0902, 0x0928, 0x0939,
 248         0x0940, 0x0902, 0x092C, 0x094B, 0x0932, 0x0938, 0x0915, 0x0924, 0x0947,
 249         0x0939, 0x0948, 0x0902, 0x0000
 250     },
 251     {
 252         0x306A, 0x305C, 0x307F, 0x3093, 0x306A, 0x65E5, 0x672C, 0x8A9E, 0x3092,
 253         0x8A71, 0x3057, 0x3066, 0x304F, 0x308C, 0x306A, 0x3044, 0x306E, 0x304B,
 254         0x0000
 255     },
 256 /*
 257     {
 258         0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774,
 259         0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74,
 260         0xC5BC, 0xB9C8, 0xB098, 0xC88B, 0xC744, 0xAE4C, 0x0000
 261     },
 262 */
 263     {
 264         0x043F, 0x043E, 0x0447, 0x0435, 0x043C, 0x0443, 0x0436, 0x0435, 0x043E,
 265         0x043D, 0x0438, 0x043D, 0x0435, 0x0433, 0x043E, 0x0432, 0x043E, 0x0440,
 266         0x044F, 0x0442, 0x043F, 0x043E, 0x0440, 0x0443, 0x0441, 0x0441, 0x043A,
 267         0x0438, 0x0000
 268     },
 269     {
 270         0x0050, 0x006F, 0x0072, 0x0071, 0x0075, 0x00E9, 0x006E, 0x006F, 0x0070,
 271         0x0075, 0x0065, 0x0064, 0x0065, 0x006E, 0x0073, 0x0069, 0x006D, 0x0070,
 272         0x006C, 0x0065, 0x006D, 0x0065, 0x006E, 0x0074, 0x0065, 0x0068, 0x0061,
 273         0x0062, 0x006C, 0x0061, 0x0072, 0x0065, 0x006E, 0x0045, 0x0073, 0x0070,
 274         0x0061, 0x00F1, 0x006F, 0x006C, 0x0000
 275     },
 276     {
 277         0x4ED6, 0x5011, 0x7232, 0x4EC0, 0x9EBD, 0x4E0D, 0x8AAA, 0x4E2D, 0x6587,
 278         0x0000
 279     },
 280     {
 281         0x0054, 0x1EA1, 0x0069, 0x0073, 0x0061, 0x006F, 0x0068, 0x1ECD, 0x006B,
 282         0x0068, 0x00F4, 0x006E, 0x0067, 0x0074, 0x0068, 0x1EC3, 0x0063, 0x0068,
 283         0x1EC9, 0x006E, 0x00F3, 0x0069, 0x0074, 0x0069, 0x1EBF, 0x006E, 0x0067,
 284         0x0056, 0x0069, 0x1EC7, 0x0074, 0x0000
 285     },
 286     {
 287         0x0033, 0x5E74, 0x0042, 0x7D44, 0x91D1, 0x516B, 0x5148, 0x751F, 0x0000
 288     },
 289     {
 290         0x5B89, 0x5BA4, 0x5948, 0x7F8E, 0x6075, 0x002D, 0x0077, 0x0069, 0x0074,
 291         0x0068, 0x002D, 0x0053, 0x0055, 0x0050, 0x0045, 0x0052, 0x002D, 0x004D,
 292         0x004F, 0x004E, 0x004B, 0x0045, 0x0059, 0x0053, 0x0000
 293     },
 294     {
 295         0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x002D, 0x0041, 0x006E, 0x006F,
 296         0x0074, 0x0068, 0x0065, 0x0072, 0x002D, 0x0057, 0x0061, 0x0079, 0x002D,
 297         0x305D, 0x308C, 0x305E, 0x308C, 0x306E, 0x5834, 0x6240, 0x0000
 298     },
 299     {
 300         0x3072, 0x3068, 0x3064, 0x5C4B, 0x6839, 0x306E, 0x4E0B, 0x0032, 0x0000
 301     },
 302     {
 303         0x004D, 0x0061, 0x006A, 0x0069, 0x3067, 0x004B, 0x006F, 0x0069, 0x3059,
 304         0x308B, 0x0035, 0x79D2, 0x524D, 0x0000
 305     },
 306     {
 307         0x30D1, 0x30D5, 0x30A3, 0x30FC, 0x0064, 0x0065, 0x30EB, 0x30F3, 0x30D0,
 308         0x0000
 309     },
 310     {
 311         0x305D, 0x306E, 0x30B9, 0x30D4, 0x30FC, 0x30C9, 0x3067, 0x0000
 312     },
 313     /* test non-BMP code points */
 314     {
 315         0xD800, 0xDF00, 0xD800, 0xDF01, 0xD800, 0xDF02, 0xD800, 0xDF03, 0xD800, 0xDF05,
 316         0xD800, 0xDF06, 0xD800, 0xDF07, 0xD800, 0xDF09, 0xD800, 0xDF0A, 0xD800, 0xDF0B,
 317         0x0000
 318     },
 319     {
 320         0xD800, 0xDF0D, 0xD800, 0xDF0C, 0xD800, 0xDF1E, 0xD800, 0xDF0F, 0xD800, 0xDF16,
 321         0xD800, 0xDF15, 0xD800, 0xDF14, 0xD800, 0xDF12, 0xD800, 0xDF10, 0xD800, 0xDF20,
 322         0xD800, 0xDF21,
 323         0x0000
 324     },
 325     /* Greek  */
 326     {
 327         0x03b5, 0x03bb, 0x03bb, 0x03b7, 0x03bd, 0x03b9, 0x03ba, 0x03ac
 328     },
 329     /* Maltese */
 330     {
 331         0x0062, 0x006f, 0x006e, 0x0121, 0x0075, 0x0073, 0x0061, 0x0127,
 332         0x0127, 0x0061
 333     },
 334     /* Russian */
 335     {
 336         0x043f, 0x043e, 0x0447, 0x0435, 0x043c, 0x0443, 0x0436, 0x0435,
 337         0x043e, 0x043d, 0x0438, 0x043d, 0x0435, 0x0433, 0x043e, 0x0432,
 338         0x043e, 0x0440, 0x044f, 0x0442, 0x043f, 0x043e, 0x0440, 0x0443,
 339         0x0441, 0x0441, 0x043a, 0x0438
 340     },
 341     {
 342         0x0054,0x0045,0x0053,0x0054
 343     }
 344 };
 345
 346 static const char *asciiIn[] = {
 347     "xn--egbpdaj6bu4bxfgehfvwxn",
 348     "xn--ihqwcrb4cv8a8dqg056pqjye",
 349     "xn--Proprostnemluvesky-uyb24dma41a",
 350     "xn--4dbcagdahymbxekheh6e0a7fei0b",
 351     "xn--i1baa7eci9glrd9b2ae1bj0hfcgg6iyaf8o0a1dig0cd",
 352     "xn--n8jok5ay5dzabd5bym9f0cm5685rrjetr6pdxa",
 353 /*  "xn--989aomsvi5e83db1d2a355cv1e0vak1dwrv93d5xbh15a0dt30a5jpsd879ccm6fea98c",*/
 354     "xn--b1abfaaepdrnnbgefbaDotcwatmq2g4l",
 355     "xn--PorqunopuedensimplementehablarenEspaol-fmd56a",
 356     "xn--ihqwctvzc91f659drss3x8bo0yb",
 357     "xn--TisaohkhngthchnitingVit-kjcr8268qyxafd2f1b9g",
 358     "xn--3B-ww4c5e180e575a65lsy2b",
 359     "xn---with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n",
 360     "xn--Hello-Another-Way--fc4qua05auwb3674vfr0b",
 361     "xn--2-u9tlzr9756bt3uc0v",
 362     "xn--MajiKoi5-783gue6qz075azm5e",
 363     "xn--de-jg4avhby1noc0d",
 364     "xn--d9juau41awczczp",
 365     "XN--097CCDEKGHQJK",
 366     "XN--db8CBHEJLGH4E0AL",
 367     "xn--hxargifdar",                       /* Greek */
 368     "xn--bonusaa-5bb1da",                   /* Maltese */
 369     "xn--b1abfaaepdrnnbgefbadotcwatmq2g4l",  /* Russian (Cyrillic)*/
 370     "TEST"
 371
 372 };
 373
 374 static const char *domainNames[] = {
 375     "slip129-37-118-146.nc.us.ibm.net",
 376     "saratoga.pe.utexas.edu",
 377     "dial-120-45.ots.utexas.edu",
 378     "woo-085.dorms.waller.net",
 379     "hd30-049.hil.compuserve.com",
 380     "pem203-31.pe.ttu.edu",
 381     "56K-227.MaxTNT3.pdq.net",
 382     "dial-36-2.ots.utexas.edu",
 383     "slip129-37-23-152.ga.us.ibm.net",
 384     "ts45ip119.cadvision.com",
 385     "sdn-ts-004txaustP05.dialsprint.net",
 386     "bar-tnt1s66.erols.com",
 387     "101.st-louis-15.mo.dial-access.att.net",
 388     "h92-245.Arco.COM",
 389     "dial-13-2.ots.utexas.edu",
 390     "net-redynet29.datamarkets.com.ar",
 391     "ccs-shiva28.reacciun.net.ve",
 392     "7.houston-11.tx.dial-access.att.net",
 393     "ingw129-37-120-26.mo.us.ibm.net",
 394     "dialup6.austintx.com",
 395     "dns2.tpao.gov.tr",
 396     "slip129-37-119-194.nc.us.ibm.net",
 397     "cs7.dillons.co.uk.203.119.193.in-addr.arpa",
 398     "swprd1.innovplace.saskatoon.sk.ca",
 399     "bikini.bologna.maraut.it",
 400     "node91.subnet159-198-79.baxter.com",
 401     "cust19.max5.new-york.ny.ms.uu.net",
 402     "balexander.slip.andrew.cmu.edu",
 403     "pool029.max2.denver.co.dynip.alter.net",
 404     "cust49.max9.new-york.ny.ms.uu.net",
 405     "s61.abq-dialin2.hollyberry.com",
 406     "\\u0917\\u0928\\u0947\\u0936.sanjose.ibm.com", /*':'(0x003a) produces U_IDNA_STD3_ASCII_RULES_ERROR*/
 407     "www.xn--vea.com",
 408     /* "www.\\u00E0\\u00B3\\u00AF.com",//' ' (0x0020) produces U_IDNA_STD3_ASCII_RULES_ERROR*/
 409     "www.\\u00C2\\u00A4.com",
 410     "www.\\u00C2\\u00A3.com",
 411     /* "\\u0025", //'%' (0x0025) produces U_IDNA_STD3_ASCII_RULES_ERROR*/
 412     /* "\\u005C\\u005C", //'\' (0x005C) produces U_IDNA_STD3_ASCII_RULES_ERROR*/
 413     /*"@",*/
 414     /*"\\u002F",*/
 415     /*"www.\\u0021.com",*/
 416     /*"www.\\u0024.com",*/
 417     /*"\\u003f",*/
 418     /* These yeild U_IDNA_PROHIBITED_ERROR*/
 419     /*"\\u00CF\\u0082.com",*/
 420     /*"\\u00CE\\u00B2\\u00C3\\u009Fss.com",*/
 421     /*"\\u00E2\\u0098\\u00BA.com",*/
 422     "\\u00C3\\u00BC.com"
 423
 424 };
 425
 426 static void
 427 TestToASCII(){
 428
 429     int32_t i;
 430     UChar buf[MAX_DEST_SIZE];
 431     const char* testName = "uidna_toASCII";
 432     TestFunc func = uidna_toASCII;
 433     for(i=0;i< (int32_t)(sizeof(unicodeIn)/sizeof(unicodeIn[0])); i++){
 434         u_charsToUChars(asciiIn[i],buf, (int32_t)strlen(asciiIn[i])+1);
 435         testAPI(unicodeIn[i], buf,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func);
 436
 437     }
 438 }
 439
 440 static void
 441 TestToUnicode(){
 442
 443     int32_t i;
 444     UChar buf[MAX_DEST_SIZE];
 445     const char* testName = "uidna_toUnicode";
 446     TestFunc func = uidna_toUnicode;
 447     for(i=0;i< (int32_t)(sizeof(asciiIn)/sizeof(asciiIn[0])); i++){
 448         u_charsToUChars(asciiIn[i],buf, (int32_t)strlen(asciiIn[i])+1);
 449         testAPI(buf,unicodeIn[i],testName,FALSE,U_ZERO_ERROR, TRUE, TRUE, func);
 450     }
 451 }
 452
 453
 454 static void
 455 TestIDNToUnicode(){
 456     int32_t i;
 457     UChar buf[MAX_DEST_SIZE];
 458     UChar expected[MAX_DEST_SIZE];
 459     UErrorCode status = U_ZERO_ERROR;
 460     int32_t bufLen = 0;
 461     UParseError parseError;
 462     const char* testName="uidna_IDNToUnicode";
 463     TestFunc func = uidna_IDNToUnicode;
 464     for(i=0;i< (int32_t)(sizeof(domainNames)/sizeof(domainNames[0])); i++){
 465         bufLen = (int32_t)strlen(domainNames[i]);
 466         bufLen = u_unescape(domainNames[i],buf, bufLen+1);
 467         func(buf,bufLen,expected,MAX_DEST_SIZE, UIDNA_ALLOW_UNASSIGNED, &parseError,&status);
 468         if(U_FAILURE(status)){
 469             log_err( "%s failed to convert domainNames[%i].Error: %s \n",testName, i, u_errorName(status));
 470             break;
 471         }
 472         testAPI(buf,expected,testName,FALSE,U_ZERO_ERROR, TRUE, TRUE, func);
 473          /*test toUnicode with all labels in the string*/
 474         testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func);
 475         if(U_FAILURE(status)){
 476             log_err( "%s failed to convert domainNames[%i].Error: %s \n",testName,i, u_errorName(status));
 477             break;
 478         }
 479     }
 480
 481 }
 482
 483 static void
 484 TestIDNToASCII(){
 485     int32_t i;
 486     UChar buf[MAX_DEST_SIZE];
 487     UChar expected[MAX_DEST_SIZE];
 488     UErrorCode status = U_ZERO_ERROR;
 489     int32_t bufLen = 0;
 490     UParseError parseError;
 491     const char* testName="udina_IDNToASCII";
 492     TestFunc func=uidna_IDNToASCII;
 493
 494     for(i=0;i< (int32_t)(sizeof(domainNames)/sizeof(domainNames[0])); i++){
 495         bufLen = (int32_t)strlen(domainNames[i]);
 496         bufLen = u_unescape(domainNames[i],buf, bufLen+1);
 497         func(buf,bufLen,expected,MAX_DEST_SIZE, UIDNA_ALLOW_UNASSIGNED, &parseError,&status);
 498         if(U_FAILURE(status)){
 499             log_err( "%s failed to convert domainNames[%i].Error: %s \n",testName,i, u_errorName(status));
 500             break;
 501         }
 502         testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func);
 503         /*test toASCII with all labels in the string*/
 504         testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, FALSE, TRUE, func);
 505         if(U_FAILURE(status)){
 506             log_err( "%s failed to convert domainNames[%i].Error: %s \n",testName,i, u_errorName(status));
 507             break;
 508         }
 509     }
 510
 511
 512 }
 513
 514
 515 static void
 516 testCompareWithSrc(const UChar* s1, int32_t s1Len,
 517             const UChar* s2, int32_t s2Len,
 518             const char* testName, CompareFunc func,
 519             UBool isEqual){
 520
 521     UErrorCode status = U_ZERO_ERROR;
 522     int32_t retVal = func(s1,-1,s2,-1,UIDNA_DEFAULT,&status);
 523
 524     if(isEqual==TRUE &&  retVal !=0){
 525         log_err("Did not get the expected result for %s with null termniated strings.\n",testName);
 526     }
 527     if(U_FAILURE(status)){
 528         log_err( "%s null terminated source failed. Error: %s\n", testName,u_errorName(status));
 529     }
 530
 531     status = U_ZERO_ERROR;
 532     retVal = func(s1,-1,s2,-1,UIDNA_ALLOW_UNASSIGNED,&status);
 533
 534     if(isEqual==TRUE &&  retVal !=0){
 535         log_err("Did not get the expected result for %s with null termniated strings with options set.\n", testName);
 536     }
 537     if(U_FAILURE(status)){
 538         log_err( "%s null terminated source and options set failed. Error: %s\n",testName, u_errorName(status));
 539     }
 540
 541     status = U_ZERO_ERROR;
 542     retVal = func(s1,s1Len,s2,s2Len,UIDNA_DEFAULT,&status);
 543
 544     if(isEqual==TRUE &&  retVal !=0){
 545         log_err("Did not get the expected result for %s with string length.\n",testName);
 546     }
 547     if(U_FAILURE(status)){
 548         log_err( "%s with string length. Error: %s\n",testName, u_errorName(status));
 549     }
 550
 551     status = U_ZERO_ERROR;
 552     retVal = func(s1,s1Len,s2,s2Len,UIDNA_ALLOW_UNASSIGNED,&status);
 553
 554     if(isEqual==TRUE &&  retVal !=0){
 555         log_err("Did not get the expected result for %s with string length and options set.\n",testName);
 556     }
 557     if(U_FAILURE(status)){
 558         log_err( "%s with string length and options set. Error: %s\n", u_errorName(status), testName);
 559     }
 560 }
 561
 562
 563 static void
 564 TestCompare(){
 565     int32_t i;
 566
 567     const char* testName ="uidna_compare";
 568     CompareFunc func = uidna_compare;
 569
 570     UChar www[] = {0x0057, 0x0057, 0x0057, 0x002E, 0x0000};
 571     UChar com[] = {0x002E, 0x0043, 0x004F, 0x004D, 0x0000};
 572     UChar buf[MAX_DEST_SIZE]={0x0057, 0x0057, 0x0057, 0x002E, 0x0000};
 573     UChar source[MAX_DEST_SIZE]={0},
 574           uni0[MAX_DEST_SIZE]={0},
 575           uni1[MAX_DEST_SIZE]={0},
 576           ascii0[MAX_DEST_SIZE]={0},
 577           ascii1[MAX_DEST_SIZE]={0},
 578           temp[MAX_DEST_SIZE] ={0};
 579
 580
 581     u_strcat(uni0,unicodeIn[0]);
 582     u_strcat(uni0,com);
 583
 584     u_strcat(uni1,unicodeIn[1]);
 585     u_strcat(uni1,com);
 586
 587     u_charsToUChars(asciiIn[0], temp, (int32_t)strlen(asciiIn[0]));
 588     u_strcat(ascii0,temp);
 589     u_strcat(ascii0,com);
 590
 591     memset(temp, 0, U_SIZEOF_UCHAR * MAX_DEST_SIZE);
 592
 593     u_charsToUChars(asciiIn[1], temp, (int32_t)strlen(asciiIn[1]));
 594     u_strcat(ascii1,temp);
 595     u_strcat(ascii1,com);
 596
 597     /* prepend www. */
 598     u_strcat(source, www);
 599
 600     for(i=0;i< (int32_t)(sizeof(unicodeIn)/sizeof(unicodeIn[0])); i++){
 601         UChar* src;
 602         int32_t srcLen;
 603
 604         memset(buf+4, 0, (MAX_DEST_SIZE-4) * U_SIZEOF_UCHAR);
 605
 606         u_charsToUChars(asciiIn[i],buf+4, (int32_t)strlen(asciiIn[i]));
 607         u_strcat(buf,com);
 608
 609
 610         /* for every entry in unicodeIn array
 611            prepend www. and append .com*/
 612         source[4]=0;
 613         u_strncat(source,unicodeIn[i], u_strlen(unicodeIn[i]));
 614         u_strcat(source,com);
 615
 616         /* a) compare it with itself*/
 617         src = source;
 618         srcLen = u_strlen(src);
 619
 620         testCompareWithSrc(src,srcLen,src,srcLen,testName, func, TRUE);
 621
 622         /* b) compare it with asciiIn equivalent */
 623         testCompareWithSrc(src,srcLen,buf,u_strlen(buf),testName, func,TRUE);
 624
 625         /* c) compare it with unicodeIn not equivalent*/
 626         if(i==0){
 627             testCompareWithSrc(src,srcLen,uni1,u_strlen(uni1),testName, func,FALSE);
 628         }else{
 629             testCompareWithSrc(src,srcLen,uni0,u_strlen(uni0),testName, func,FALSE);
 630         }
 631         /* d) compare it with asciiIn not equivalent */
 632         if(i==0){
 633             testCompareWithSrc(src,srcLen,ascii1,u_strlen(ascii1),testName, func,FALSE);
 634         }else{
 635             testCompareWithSrc(src,srcLen,ascii0,u_strlen(ascii0),testName, func,FALSE);
 636         }
 637
 638     }
 639 }
 640
 641 static void TestUnicode32Norm() {
 642     /*
 643      * test Unicode 3.2 normalization, before Public Review Issue #29
 644      * see cnormtst.c TestComposition()
 645      */
 646     static const UChar strings[][8]={
 647         { 0x1100, 0x0300, 0x1161, 0x0327 },
 648         { 0x0b47, 0x0300, 0x0b3e, 0x0327 }
 649     };
 650
 651     UChar ascii[20], unicode[20];
 652     int32_t i, length;
 653     UErrorCode errorCode;
 654
 655     for(i=0; i<LENGTHOF(strings); ++i) {
 656         errorCode=U_ZERO_ERROR;
 657         length=uidna_toASCII(strings[i], -1, ascii, LENGTHOF(ascii), 0, NULL, &errorCode);
 658         length=uidna_toUnicode(ascii, length, unicode, LENGTHOF(unicode), 0, NULL, &errorCode);
 659         if(errorCode!=U_IDNA_VERIFICATION_ERROR) {
 660             log_err("string %d yields %s instead of U_IDNA_VERIFICATION_ERROR\n",
 661                 i, u_errorName(errorCode));
 662         }
 663     }
 664 }
 665
 666 static void TestJB4490(){
 667     static const UChar data[][50]= {
 668         {0x00F5,0x00dE,0x00dF,0x00dD, 0x0000},
 669         {0xFB00,0xFB01}
 670     };
 671     UChar output1[40] = {0};
 672     UChar output2[40] = {0};
 673     int32_t i;
 674     for(i=0; i< sizeof(data)/sizeof(data[0]); i++){
 675         const UChar* src1 = data[i];
 676         int32_t src1Len = u_strlen(src1);
 677         UChar* dest1 = output1;
 678         int32_t dest1Len = 40;
 679         UErrorCode status = U_ZERO_ERROR;
 680         UParseError ps;
 681         UChar* src2 = NULL;
 682         int32_t src2Len = 0;
 683         UChar* dest2 = output2;
 684         int32_t dest2Len = 40;
 685         dest1Len = uidna_toASCII(src1, src1Len, dest1, dest1Len,UIDNA_DEFAULT, &ps, &status);
 686         if(U_FAILURE(status)){
 687             log_err("uidna_toUnicode failed with error %s.\n", u_errorName(status));
 688         }
 689         src2 = dest1;
 690         src2Len = dest1Len;
 691         dest2Len = uidna_toUnicode(src2, src2Len, dest2, dest2Len, UIDNA_DEFAULT, &ps, &status);
 692         if(U_FAILURE(status)){
 693             log_err("uidna_toUnicode failed with error %s.\n", u_errorName(status));
 694         }
 695     }
 696 }
 697
 698 static void TestJB4475(){
 699
 700     static const UChar input[][10] = {
 701         {0x0054,0x0045,0x0053,0x0054,0x0000},/* TEST */
 702         {0x0074,0x0065,0x0073,0x0074,0x0000} /* test */
 703     };
 704     int i;
 705     UChar output[40] = {0};
 706     for(i=0; i< sizeof(input)/sizeof(input[0]); i++){
 707         const UChar* src = input[i];
 708         int32_t srcLen = u_strlen(src);
 709         UChar* dest = output;
 710         int32_t destLen = 40;
 711         UErrorCode status = U_ZERO_ERROR;
 712         UParseError ps;
 713
 714         destLen = uidna_toASCII(src, srcLen, dest, destLen,UIDNA_DEFAULT, &ps, &status);
 715         if(U_FAILURE(status)){
 716             log_err("uidna_toASCII failed with error %s.\n", u_errorName(status));
 717         }
 718         if(u_strncmp(input[i], dest, srcLen)!=0){
 719             log_err("uidna_toASCII did not return the expected output.\n");
 720         }
 721     }
 722 }
 723 static void TestLength(){
 724     {
 725           static const char* cl = "my_very_very_very_very_very_very_very_long_and_incredibly_uncreative_domain_label";
 726           UChar ul[128] = {'\0'};
 727           UChar dest[256] = {'\0'};
 728           int32_t destLen = LENGTHOF(dest);
 729           UErrorCode status = U_ZERO_ERROR;
 730           UParseError ps;
 731           int32_t len = (int32_t)strlen(cl);
 732           u_charsToUChars(cl, ul, len+1);
 733           destLen = uidna_toUnicode(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 734           if(status != U_ZERO_ERROR){
 735               log_err("uidna_toUnicode failed with error %s.\n", u_errorName(status));
 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("uidna_toUnicode failed with error %s.\n", u_errorName(status));
 743           }
 744
 745           status = U_ZERO_ERROR;
 746           destLen = LENGTHOF(dest);
 747           len = -1;
 748           destLen = uidna_toASCII(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 749           if(status != U_IDNA_LABEL_TOO_LONG_ERROR){
 750               log_err("uidna_toASCII failed with error %s.\n", u_errorName(status));
 751           }
 752
 753           status = U_ZERO_ERROR;
 754           destLen = LENGTHOF(dest);
 755           len = -1;
 756           destLen = uidna_toASCII(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 757           if(status != U_IDNA_LABEL_TOO_LONG_ERROR){
 758               log_err("uidna_toASCII failed with error %s.\n", u_errorName(status));
 759           }
 760     }
 761 }
 762 #endif
 763
 764 /*
 765  * Hey, Emacs, please set the following:
 766  *
 767  * Local Variables:
 768  * indent-tabs-mode: nil
 769  * End:
 770  *
 771  */
 772