icuSources/test/cintltst/idnatest.c

   1 /*
   2  *******************************************************************************
   3  *
   4  *   Copyright (C) 2003-2016, International Business Machines
   5  *   Corporation and others.  All Rights Reserved.
   6  *
   7  *******************************************************************************
   8  *   file name:  idnatest.c
   9  *   encoding:   US-ASCII
  10  *   tab size:   8 (not used)
  11  *   indentation:4
  12  *
  13  *   created on: 2003jul11
  14  *   created by: Ram Viswanadha
  15  */
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include "unicode/utypes.h"
  19
  20 #if !UCONFIG_NO_IDNA
  21
  22 #include "unicode/ustring.h"
  23 #include "unicode/uidna.h"
  24 #include "cintltst.h"
  25 #include "cmemory.h"
  26
  27 #define MAX_DEST_SIZE 1000
  28
  29 static void TestToUnicode(void);
  30 static void TestToASCII(void);
  31 static void TestIDNToUnicode(void);
  32 static void TestIDNToASCII(void);
  33 static void TestCompare(void);
  34 static void TestJB4490(void);
  35 static void TestJB4475(void);
  36 static void TestLength(void);
  37 static void TestJB5273(void);
  38 static void TestUTS46(void);
  39
  40 void addIDNATest(TestNode** root);
  41
  42
  43 typedef int32_t
  44 (U_EXPORT2 *TestFunc) (   const UChar *src, int32_t srcLength,
  45                 UChar *dest, int32_t destCapacity,
  46                 int32_t options, UParseError *parseError,
  47                 UErrorCode *status);
  48 typedef int32_t
  49 (U_EXPORT2 *CompareFunc) (const UChar *s1, int32_t s1Len,
  50                 const UChar *s2, int32_t s2Len,
  51                 int32_t options,
  52                 UErrorCode *status);
  53
  54
  55 void
  56 addIDNATest(TestNode** root)
  57 {
  58    addTest(root, &TestToUnicode,    "idna/TestToUnicode");
  59    addTest(root, &TestToASCII,      "idna/TestToASCII");
  60    addTest(root, &TestIDNToUnicode, "idna/TestIDNToUnicode");
  61    addTest(root, &TestIDNToASCII,   "idna/TestIDNToASCII");
  62    addTest(root, &TestCompare,      "idna/TestCompare");
  63    addTest(root, &TestJB4490,       "idna/TestJB4490");
  64    addTest(root, &TestJB4475,       "idna/TestJB4475");
  65    addTest(root, &TestLength,       "idna/TestLength");
  66    addTest(root, &TestJB5273,       "idna/TestJB5273");
  67    addTest(root, &TestUTS46,        "idna/TestUTS46");
  68 }
  69
  70 static void
  71 testAPI(const UChar* src, const UChar* expected, const char* testName,
  72             UBool useSTD3ASCIIRules,UErrorCode expectedStatus,
  73             UBool doCompare, UBool testUnassigned,  TestFunc func){
  74
  75     UErrorCode status = U_ZERO_ERROR;
  76     UChar destStack[MAX_DEST_SIZE];
  77     int32_t destLen = 0;
  78     UChar* dest = NULL;
  79     int32_t expectedLen = (expected != NULL) ? u_strlen(expected) : 0;
  80     int32_t options = (useSTD3ASCIIRules == TRUE) ? UIDNA_USE_STD3_RULES : UIDNA_DEFAULT;
  81     UParseError parseError;
  82     int32_t tSrcLen = 0;
  83     UChar* tSrc = NULL;
  84
  85     if(src != NULL){
  86         tSrcLen = u_strlen(src);
  87         tSrc  =(UChar*) malloc( U_SIZEOF_UCHAR * tSrcLen );
  88         memcpy(tSrc,src,tSrcLen * U_SIZEOF_UCHAR);
  89     }
  90
  91     /* test null-terminated source and return value of number of UChars required */
  92
  93     destLen = func(src,-1,NULL,0,options, &parseError , &status);
  94     if(status == U_BUFFER_OVERFLOW_ERROR){
  95         status = U_ZERO_ERROR; /* reset error code */
  96         if(destLen+1 < MAX_DEST_SIZE){
  97             dest = destStack;
  98             destLen = func(src,-1,dest,destLen+1,options, &parseError, &status);
  99             /* TODO : compare output with expected */
 100             if(U_SUCCESS(status) && expectedStatus != U_IDNA_STD3_ASCII_RULES_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_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));
 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 const UChar unicodeIn[][41] ={
 227     {
 228         0x0644, 0x064A, 0x0647, 0x0645, 0x0627, 0x0628, 0x062A, 0x0643, 0x0644,
 229         0x0645, 0x0648, 0x0634, 0x0639, 0x0631, 0x0628, 0x064A, 0x061F, 0x0000
 230     },
 231     {
 232         0x4ED6, 0x4EEC, 0x4E3A, 0x4EC0, 0x4E48, 0x4E0D, 0x8BF4, 0x4E2D, 0x6587,
 233         0x0000
 234     },
 235     {
 236         0x0050, 0x0072, 0x006F, 0x010D, 0x0070, 0x0072, 0x006F, 0x0073, 0x0074,
 237         0x011B, 0x006E, 0x0065, 0x006D, 0x006C, 0x0075, 0x0076, 0x00ED, 0x010D,
 238         0x0065, 0x0073, 0x006B, 0x0079, 0x0000
 239     },
 240     {
 241         0x05DC, 0x05DE, 0x05D4, 0x05D4, 0x05DD, 0x05E4, 0x05E9, 0x05D5, 0x05D8,
 242         0x05DC, 0x05D0, 0x05DE, 0x05D3, 0x05D1, 0x05E8, 0x05D9, 0x05DD, 0x05E2,
 243         0x05D1, 0x05E8, 0x05D9, 0x05EA, 0x0000
 244     },
 245     {
 246         0x092F, 0x0939, 0x0932, 0x094B, 0x0917, 0x0939, 0x093F, 0x0928, 0x094D,
 247         0x0926, 0x0940, 0x0915, 0x094D, 0x092F, 0x094B, 0x0902, 0x0928, 0x0939,
 248         0x0940, 0x0902, 0x092C, 0x094B, 0x0932, 0x0938, 0x0915, 0x0924, 0x0947,
 249         0x0939, 0x0948, 0x0902, 0x0000
 250     },
 251     {
 252         0x306A, 0x305C, 0x307F, 0x3093, 0x306A, 0x65E5, 0x672C, 0x8A9E, 0x3092,
 253         0x8A71, 0x3057, 0x3066, 0x304F, 0x308C, 0x306A, 0x3044, 0x306E, 0x304B,
 254         0x0000
 255     },
 256 /*
 257     {
 258         0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774,
 259         0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0xD574, 0xD55C, 0xB2E4, 0xBA74,
 260         0xC5BC, 0xB9C8, 0xB098, 0xC88B, 0xC744, 0xAE4C, 0x0000
 261     },
 262 */
 263     {
 264         0x043F, 0x043E, 0x0447, 0x0435, 0x043C, 0x0443, 0x0436, 0x0435, 0x043E,
 265         0x043D, 0x0438, 0x043D, 0x0435, 0x0433, 0x043E, 0x0432, 0x043E, 0x0440,
 266         0x044F, 0x0442, 0x043F, 0x043E, 0x0440, 0x0443, 0x0441, 0x0441, 0x043A,
 267         0x0438, 0x0000
 268     },
 269     {
 270         0x0050, 0x006F, 0x0072, 0x0071, 0x0075, 0x00E9, 0x006E, 0x006F, 0x0070,
 271         0x0075, 0x0065, 0x0064, 0x0065, 0x006E, 0x0073, 0x0069, 0x006D, 0x0070,
 272         0x006C, 0x0065, 0x006D, 0x0065, 0x006E, 0x0074, 0x0065, 0x0068, 0x0061,
 273         0x0062, 0x006C, 0x0061, 0x0072, 0x0065, 0x006E, 0x0045, 0x0073, 0x0070,
 274         0x0061, 0x00F1, 0x006F, 0x006C, 0x0000
 275     },
 276     {
 277         0x4ED6, 0x5011, 0x7232, 0x4EC0, 0x9EBD, 0x4E0D, 0x8AAA, 0x4E2D, 0x6587,
 278         0x0000
 279     },
 280     {
 281         0x0054, 0x1EA1, 0x0069, 0x0073, 0x0061, 0x006F, 0x0068, 0x1ECD, 0x006B,
 282         0x0068, 0x00F4, 0x006E, 0x0067, 0x0074, 0x0068, 0x1EC3, 0x0063, 0x0068,
 283         0x1EC9, 0x006E, 0x00F3, 0x0069, 0x0074, 0x0069, 0x1EBF, 0x006E, 0x0067,
 284         0x0056, 0x0069, 0x1EC7, 0x0074, 0x0000
 285     },
 286     {
 287         0x0033, 0x5E74, 0x0042, 0x7D44, 0x91D1, 0x516B, 0x5148, 0x751F, 0x0000
 288     },
 289     {
 290         0x5B89, 0x5BA4, 0x5948, 0x7F8E, 0x6075, 0x002D, 0x0077, 0x0069, 0x0074,
 291         0x0068, 0x002D, 0x0053, 0x0055, 0x0050, 0x0045, 0x0052, 0x002D, 0x004D,
 292         0x004F, 0x004E, 0x004B, 0x0045, 0x0059, 0x0053, 0x0000
 293     },
 294     {
 295         0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x002D, 0x0041, 0x006E, 0x006F,
 296         0x0074, 0x0068, 0x0065, 0x0072, 0x002D, 0x0057, 0x0061, 0x0079, 0x002D,
 297         0x305D, 0x308C, 0x305E, 0x308C, 0x306E, 0x5834, 0x6240, 0x0000
 298     },
 299     {
 300         0x3072, 0x3068, 0x3064, 0x5C4B, 0x6839, 0x306E, 0x4E0B, 0x0032, 0x0000
 301     },
 302     {
 303         0x004D, 0x0061, 0x006A, 0x0069, 0x3067, 0x004B, 0x006F, 0x0069, 0x3059,
 304         0x308B, 0x0035, 0x79D2, 0x524D, 0x0000
 305     },
 306     {
 307         0x30D1, 0x30D5, 0x30A3, 0x30FC, 0x0064, 0x0065, 0x30EB, 0x30F3, 0x30D0,
 308         0x0000
 309     },
 310     {
 311         0x305D, 0x306E, 0x30B9, 0x30D4, 0x30FC, 0x30C9, 0x3067, 0x0000
 312     },
 313     /* test non-BMP code points */
 314     {
 315         0xD800, 0xDF00, 0xD800, 0xDF01, 0xD800, 0xDF02, 0xD800, 0xDF03, 0xD800, 0xDF05,
 316         0xD800, 0xDF06, 0xD800, 0xDF07, 0xD800, 0xDF09, 0xD800, 0xDF0A, 0xD800, 0xDF0B,
 317         0x0000
 318     },
 319     {
 320         0xD800, 0xDF0D, 0xD800, 0xDF0C, 0xD800, 0xDF1E, 0xD800, 0xDF0F, 0xD800, 0xDF16,
 321         0xD800, 0xDF15, 0xD800, 0xDF14, 0xD800, 0xDF12, 0xD800, 0xDF10, 0xD800, 0xDF20,
 322         0xD800, 0xDF21,
 323         0x0000
 324     },
 325     /* Greek  */
 326     {
 327         0x03b5, 0x03bb, 0x03bb, 0x03b7, 0x03bd, 0x03b9, 0x03ba, 0x03ac
 328     },
 329     /* Maltese */
 330     {
 331         0x0062, 0x006f, 0x006e, 0x0121, 0x0075, 0x0073, 0x0061, 0x0127,
 332         0x0127, 0x0061
 333     },
 334     /* Russian */
 335     {
 336         0x043f, 0x043e, 0x0447, 0x0435, 0x043c, 0x0443, 0x0436, 0x0435,
 337         0x043e, 0x043d, 0x0438, 0x043d, 0x0435, 0x0433, 0x043e, 0x0432,
 338         0x043e, 0x0440, 0x044f, 0x0442, 0x043f, 0x043e, 0x0440, 0x0443,
 339         0x0441, 0x0441, 0x043a, 0x0438
 340     },
 341     {
 342         0x0054,0x0045,0x0053,0x0054
 343     }
 344 };
 345
 346 static const char * const asciiIn[] = {
 347     "xn--egbpdaj6bu4bxfgehfvwxn",
 348     "xn--ihqwcrb4cv8a8dqg056pqjye",
 349     "xn--Proprostnemluvesky-uyb24dma41a",
 350     "xn--4dbcagdahymbxekheh6e0a7fei0b",
 351     "xn--i1baa7eci9glrd9b2ae1bj0hfcgg6iyaf8o0a1dig0cd",
 352     "xn--n8jok5ay5dzabd5bym9f0cm5685rrjetr6pdxa",
 353 /*  "xn--989aomsvi5e83db1d2a355cv1e0vak1dwrv93d5xbh15a0dt30a5jpsd879ccm6fea98c",*/
 354     "xn--b1abfaaepdrnnbgefbaDotcwatmq2g4l",
 355     "xn--PorqunopuedensimplementehablarenEspaol-fmd56a",
 356     "xn--ihqwctvzc91f659drss3x8bo0yb",
 357     "xn--TisaohkhngthchnitingVit-kjcr8268qyxafd2f1b9g",
 358     "xn--3B-ww4c5e180e575a65lsy2b",
 359     "xn---with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n",
 360     "xn--Hello-Another-Way--fc4qua05auwb3674vfr0b",
 361     "xn--2-u9tlzr9756bt3uc0v",
 362     "xn--MajiKoi5-783gue6qz075azm5e",
 363     "xn--de-jg4avhby1noc0d",
 364     "xn--d9juau41awczczp",
 365     "XN--097CCDEKGHQJK",
 366     "XN--db8CBHEJLGH4E0AL",
 367     "xn--hxargifdar",                       /* Greek */
 368     "xn--bonusaa-5bb1da",                   /* Maltese */
 369     "xn--b1abfaaepdrnnbgefbadotcwatmq2g4l",  /* Russian (Cyrillic)*/
 370     "TEST"
 371
 372 };
 373
 374 static const char * const domainNames[] = {
 375     "slip129-37-118-146.nc.us.ibm.net",
 376     "saratoga.pe.utexas.edu",
 377     "dial-120-45.ots.utexas.edu",
 378     "woo-085.dorms.waller.net",
 379     "hd30-049.hil.compuserve.com",
 380     "pem203-31.pe.ttu.edu",
 381     "56K-227.MaxTNT3.pdq.net",
 382     "dial-36-2.ots.utexas.edu",
 383     "slip129-37-23-152.ga.us.ibm.net",
 384     "ts45ip119.cadvision.com",
 385     "sdn-ts-004txaustP05.dialsprint.net",
 386     "bar-tnt1s66.erols.com",
 387     "101.st-louis-15.mo.dial-access.att.net",
 388     "h92-245.Arco.COM",
 389     "dial-13-2.ots.utexas.edu",
 390     "net-redynet29.datamarkets.com.ar",
 391     "ccs-shiva28.reacciun.net.ve",
 392     "7.houston-11.tx.dial-access.att.net",
 393     "ingw129-37-120-26.mo.us.ibm.net",
 394     "dialup6.austintx.com",
 395     "dns2.tpao.gov.tr",
 396     "slip129-37-119-194.nc.us.ibm.net",
 397     "cs7.dillons.co.uk.203.119.193.in-addr.arpa",
 398     "swprd1.innovplace.saskatoon.sk.ca",
 399     "bikini.bologna.maraut.it",
 400     "node91.subnet159-198-79.baxter.com",
 401     "cust19.max5.new-york.ny.ms.uu.net",
 402     "balexander.slip.andrew.cmu.edu",
 403     "pool029.max2.denver.co.dynip.alter.net",
 404     "cust49.max9.new-york.ny.ms.uu.net",
 405     "s61.abq-dialin2.hollyberry.com",
 406     "\\u0917\\u0928\\u0947\\u0936.sanjose.ibm.com", /*':'(0x003a) produces U_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< UPRV_LENGTHOF(unicodeIn); 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< UPRV_LENGTHOF(asciiIn); 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< UPRV_LENGTHOF(domainNames); 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_status(status,  "%s failed to convert domainNames[%i].Error: %s \n",testName, i, u_errorName(status));
 470             break;
 471         }
 472         testAPI(buf,expected,testName,FALSE,U_ZERO_ERROR, TRUE, TRUE, func);
 473          /*test toUnicode with all labels in the string*/
 474         testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func);
 475         if(U_FAILURE(status)){
 476             log_err( "%s failed to convert domainNames[%i].Error: %s \n",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< UPRV_LENGTHOF(domainNames); 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_status(status,  "%s failed to convert domainNames[%i].Error: %s \n",testName,i, u_errorName(status));
 500             break;
 501         }
 502         testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func);
 503         /*test toASCII with all labels in the string*/
 504         testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, FALSE, TRUE, func);
 505         if(U_FAILURE(status)){
 506             log_err( "%s failed to convert domainNames[%i].Error: %s \n",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_status(status, "%s null terminated source failed. Error: %s\n", testName,u_errorName(status));
 529     }
 530
 531     status = U_ZERO_ERROR;
 532     retVal = func(s1,-1,s2,-1,UIDNA_ALLOW_UNASSIGNED,&status);
 533
 534     if(isEqual==TRUE &&  retVal !=0){
 535         log_err("Did not get the expected result for %s with null termniated strings with options set.\n", testName);
 536     }
 537     if(U_FAILURE(status)){
 538         log_err_status(status, "%s null terminated source and options set failed. Error: %s\n",testName, u_errorName(status));
 539     }
 540
 541     status = U_ZERO_ERROR;
 542     retVal = func(s1,s1Len,s2,s2Len,UIDNA_DEFAULT,&status);
 543
 544     if(isEqual==TRUE &&  retVal !=0){
 545         log_err("Did not get the expected result for %s with string length.\n",testName);
 546     }
 547     if(U_FAILURE(status)){
 548         log_err_status(status,  "%s with string length. Error: %s\n",testName, u_errorName(status));
 549     }
 550
 551     status = U_ZERO_ERROR;
 552     retVal = func(s1,s1Len,s2,s2Len,UIDNA_ALLOW_UNASSIGNED,&status);
 553
 554     if(isEqual==TRUE &&  retVal !=0){
 555         log_err("Did not get the expected result for %s with string length and options set.\n",testName);
 556     }
 557     if(U_FAILURE(status)){
 558         log_err_status(status,  "%s with string length and options set. Error: %s\n", u_errorName(status), testName);
 559     }
 560 }
 561
 562
 563 static void
 564 TestCompare(){
 565     int32_t i;
 566
 567     const char* testName ="uidna_compare";
 568     CompareFunc func = uidna_compare;
 569
 570     UChar www[] = {0x0057, 0x0057, 0x0057, 0x002E, 0x0000};
 571     UChar com[] = {0x002E, 0x0043, 0x004F, 0x004D, 0x0000};
 572     UChar buf[MAX_DEST_SIZE]={0x0057, 0x0057, 0x0057, 0x002E, 0x0000};
 573     UChar source[MAX_DEST_SIZE]={0},
 574           uni0[MAX_DEST_SIZE]={0},
 575           uni1[MAX_DEST_SIZE]={0},
 576           ascii0[MAX_DEST_SIZE]={0},
 577           ascii1[MAX_DEST_SIZE]={0},
 578           temp[MAX_DEST_SIZE] ={0};
 579
 580
 581     u_strcat(uni0,unicodeIn[0]);
 582     u_strcat(uni0,com);
 583
 584     u_strcat(uni1,unicodeIn[1]);
 585     u_strcat(uni1,com);
 586
 587     u_charsToUChars(asciiIn[0], temp, (int32_t)strlen(asciiIn[0]));
 588     u_strcat(ascii0,temp);
 589     u_strcat(ascii0,com);
 590
 591     memset(temp, 0, U_SIZEOF_UCHAR * MAX_DEST_SIZE);
 592
 593     u_charsToUChars(asciiIn[1], temp, (int32_t)strlen(asciiIn[1]));
 594     u_strcat(ascii1,temp);
 595     u_strcat(ascii1,com);
 596
 597     /* prepend www. */
 598     u_strcat(source, www);
 599
 600     for(i=0;i< UPRV_LENGTHOF(unicodeIn); 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 TestJB4490(){
 642     static const UChar data[][50]= {
 643         {0x00F5,0x00dE,0x00dF,0x00dD, 0x0000},
 644         {0xFB00,0xFB01}
 645     };
 646     UChar output1[40] = {0};
 647     UChar output2[40] = {0};
 648     int32_t i;
 649     for(i=0; i< UPRV_LENGTHOF(data); i++){
 650         const UChar* src1 = data[i];
 651         int32_t src1Len = u_strlen(src1);
 652         UChar* dest1 = output1;
 653         int32_t dest1Len = 40;
 654         UErrorCode status = U_ZERO_ERROR;
 655         UParseError ps;
 656         UChar* src2 = NULL;
 657         int32_t src2Len = 0;
 658         UChar* dest2 = output2;
 659         int32_t dest2Len = 40;
 660         dest1Len = uidna_toASCII(src1, src1Len, dest1, dest1Len,UIDNA_DEFAULT, &ps, &status);
 661         if(U_FAILURE(status)){
 662             log_err_status(status, "uidna_toUnicode failed with error %s.\n", u_errorName(status));
 663         }
 664         src2 = dest1;
 665         src2Len = dest1Len;
 666         dest2Len = uidna_toUnicode(src2, src2Len, dest2, dest2Len, UIDNA_DEFAULT, &ps, &status);
 667         if(U_FAILURE(status)){
 668             log_err_status(status, "uidna_toUnicode failed with error %s.\n", u_errorName(status));
 669         }
 670     }
 671 }
 672
 673 static void TestJB4475(){
 674
 675     static const UChar input[][10] = {
 676         {0x0054,0x0045,0x0053,0x0054,0x0000},/* TEST */
 677         {0x0074,0x0065,0x0073,0x0074,0x0000} /* test */
 678     };
 679     int i;
 680     UChar output[40] = {0};
 681     for(i=0; i< UPRV_LENGTHOF(input); i++){
 682         const UChar* src = input[i];
 683         int32_t srcLen = u_strlen(src);
 684         UChar* dest = output;
 685         int32_t destLen = 40;
 686         UErrorCode status = U_ZERO_ERROR;
 687         UParseError ps;
 688
 689         destLen = uidna_toASCII(src, srcLen, dest, destLen,UIDNA_DEFAULT, &ps, &status);
 690         if(U_FAILURE(status)){
 691             log_err_status(status, "uidna_toASCII failed with error %s.\n", u_errorName(status));
 692             continue;
 693         }
 694         if(u_strncmp(input[i], dest, srcLen)!=0){
 695             log_err("uidna_toASCII did not return the expected output.\n");
 696         }
 697     }
 698 }
 699
 700 static void TestLength(){
 701     {
 702         static const char* cl = "my_very_very_very_very_very_very_very_very_very_very_very_very_very_long_and_incredibly_uncreative_domain_label";
 703         UChar ul[128] = {'\0'};
 704         UChar dest[256] = {'\0'};
 705         /* this unicode string is longer than MAX_LABEL_BUFFER_SIZE and produces an
 706            IDNA prepared string (including xn--)that is exactly 63 bytes long */
 707         UChar ul1[] = { 0xC138, 0xACC4, 0xC758, 0xBAA8, 0xB4E0, 0xC0AC, 0xB78C, 0xB4E4, 0xC774,
 708                         0xD55C, 0xAD6D, 0xC5B4, 0xB97C, 0xC774, 0x00AD, 0x034F, 0x1806, 0x180B,
 709                         0x180C, 0x180D, 0x200B, 0x200C, 0x200D, 0x2060, 0xFE00, 0xFE01, 0xFE02,
 710                         0xFE03, 0xFE04, 0xFE05, 0xFE06, 0xFE07, 0xFE08, 0xFE09, 0xFE0A, 0xFE0B,
 711                         0xFE0C, 0xFE0D, 0xFE0E, 0xFE0F, 0xFEFF, 0xD574, 0xD55C, 0xB2E4, 0xBA74,
 712                         0xC138, 0x0041, 0x00AD, 0x034F, 0x1806, 0x180B, 0x180C, 0x180D, 0x200B,
 713                         0x200C, 0x200D, 0x2060, 0xFE00, 0xFE01, 0xFE02, 0xFE03, 0xFE04, 0xFE05,
 714                         0xFE06, 0xFE07, 0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C, 0xFE0D, 0xFE0E,
 715                         0xFE0F, 0xFEFF, 0x00AD, 0x034F, 0x1806, 0x180B, 0x180C, 0x180D, 0x200B,
 716                         0x200C, 0x200D, 0x2060, 0xFE00, 0xFE01, 0xFE02, 0xFE03, 0xFE04, 0xFE05,
 717                         0xFE06, 0xFE07, 0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C, 0xFE0D, 0xFE0E,
 718                         0xFE0F, 0xFEFF, 0x00AD, 0x034F, 0x1806, 0x180B, 0x180C, 0x180D, 0x200B,
 719                         0x200C, 0x200D, 0x2060, 0xFE00, 0xFE01, 0xFE02, 0xFE03, 0xFE04, 0xFE05,
 720                         0xFE06, 0xFE07, 0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C, 0xFE0D, 0xFE0E,
 721                         0xFE0F, 0xFEFF, 0x0000
 722                       };
 723
 724         int32_t len1 = UPRV_LENGTHOF(ul1)-1/*remove the null termination*/;
 725         int32_t destLen = UPRV_LENGTHOF(dest);
 726         UErrorCode status = U_ZERO_ERROR;
 727         UParseError ps;
 728         int32_t len = (int32_t)strlen(cl);
 729         u_charsToUChars(cl, ul, len+1);
 730         destLen = uidna_toUnicode(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 731         if(status != U_ZERO_ERROR){
 732             log_err_status(status, "uidna_toUnicode failed with error %s.\n", u_errorName(status));
 733         }
 734
 735         status = U_ZERO_ERROR;
 736         destLen = UPRV_LENGTHOF(dest);
 737         len = -1;
 738         destLen = uidna_toUnicode(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 739         if(status != U_ZERO_ERROR){
 740             log_err_status(status, "uidna_toUnicode failed with error %s.\n", u_errorName(status));
 741         }
 742         status = U_ZERO_ERROR;
 743         destLen = UPRV_LENGTHOF(dest);
 744         len = (int32_t)strlen(cl);
 745         destLen = uidna_toASCII(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 746         if(status != U_IDNA_LABEL_TOO_LONG_ERROR){
 747             log_err_status(status, "uidna_toASCII failed with error %s.\n", u_errorName(status));
 748         }
 749
 750         status = U_ZERO_ERROR;
 751         destLen = UPRV_LENGTHOF(dest);
 752         len = -1;
 753         destLen = uidna_toASCII(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 754         if(status != U_IDNA_LABEL_TOO_LONG_ERROR){
 755             log_err_status(status, "uidna_toASCII failed with error %s.\n", u_errorName(status));
 756         }
 757
 758         status = U_ZERO_ERROR;
 759         destLen = UPRV_LENGTHOF(dest);
 760         destLen = uidna_toASCII(ul1, len1, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 761         if(status != U_ZERO_ERROR){
 762             log_err_status(status, "uidna_toASCII failed with error %s.\n", u_errorName(status));
 763         }
 764
 765         status = U_ZERO_ERROR;
 766         destLen = UPRV_LENGTHOF(dest);
 767         len1 = -1;
 768         destLen = uidna_toASCII(ul1, len1, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 769         if(status != U_ZERO_ERROR){
 770             log_err_status(status, "uidna_toASCII failed with error %s.\n", u_errorName(status));
 771         }
 772     }
 773     {
 774         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";
 775         UChar ul[400] = {'\0'};
 776         UChar dest[400] = {'\0'};
 777         int32_t destLen = UPRV_LENGTHOF(dest);
 778         UErrorCode status = U_ZERO_ERROR;
 779         UParseError ps;
 780         int32_t len = (int32_t)strlen(cl);
 781         u_charsToUChars(cl, ul, len+1);
 782
 783         destLen = uidna_IDNToUnicode(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 784         if(status != U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR){
 785             log_err_status(status, "uidna_IDNToUnicode failed with error %s.\n", u_errorName(status));
 786         }
 787
 788         status = U_ZERO_ERROR;
 789         destLen = UPRV_LENGTHOF(dest);
 790         len = -1;
 791         destLen = uidna_IDNToUnicode(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 792         if(status != U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR){
 793             log_err_status(status, "uidna_IDNToUnicode failed with error %s.\n", u_errorName(status));
 794         }
 795
 796         status = U_ZERO_ERROR;
 797         destLen = UPRV_LENGTHOF(dest);
 798         len = (int32_t)strlen(cl);
 799         destLen = uidna_IDNToASCII(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 800         if(status != U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR){
 801             log_err_status(status, "uidna_IDNToASCII failed with error %s.\n", u_errorName(status));
 802         }
 803
 804         status = U_ZERO_ERROR;
 805         destLen = UPRV_LENGTHOF(dest);
 806         len = -1;
 807         destLen = uidna_IDNToASCII(ul, len, dest, destLen, UIDNA_DEFAULT, &ps, &status);
 808         if(status != U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR){
 809             log_err_status(status, "uidna_IDNToASCII failed with error %s.\n", u_errorName(status));
 810         }
 811
 812         status = U_ZERO_ERROR;
 813         uidna_compare(ul, len, ul, len, UIDNA_DEFAULT, &status);
 814         if(status != U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR){
 815             log_err_status(status, "uidna_compare failed with error %s.\n", u_errorName(status));
 816         }
 817         uidna_compare(ul, -1, ul, -1, UIDNA_DEFAULT, &status);
 818         if(status != U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR){
 819             log_err_status(status, "uidna_compare failed with error %s.\n", u_errorName(status));
 820         }
 821     }
 822 }
 823 static void TestJB5273(){
 824     static const char INVALID_DOMAIN_NAME[] = "xn--m\\u00FCller.de";
 825     UChar invalid_idn[25] = {'\0'};
 826     int32_t len = u_unescape(INVALID_DOMAIN_NAME, invalid_idn, strlen(INVALID_DOMAIN_NAME));
 827     UChar output[50] = {'\0'};
 828     UErrorCode status = U_ZERO_ERROR;
 829     UParseError prsError;
 830     int32_t outLen = uidna_toUnicode(invalid_idn, len, output, 50, UIDNA_DEFAULT, &prsError, &status);
 831     (void)outLen;    /* Suppress set but not used warning. */
 832     if(U_FAILURE(status)){
 833         log_err_status(status, "uidna_toUnicode failed with error: %s\n", u_errorName(status));
 834     }
 835     status = U_ZERO_ERROR;
 836     outLen = uidna_toUnicode(invalid_idn, len, output, 50, UIDNA_USE_STD3_RULES, &prsError, &status);
 837     if(U_FAILURE(status)){
 838         log_err_status(status, "uidna_toUnicode failed with error: %s\n", u_errorName(status));
 839     }
 840
 841     status = U_ZERO_ERROR;
 842     outLen = uidna_IDNToUnicode(invalid_idn, len, output, 50, UIDNA_DEFAULT, &prsError, &status);
 843     if(U_FAILURE(status)){
 844         log_err_status(status, "uidna_toUnicode failed with error: %s\n", u_errorName(status));
 845     }
 846     status = U_ZERO_ERROR;
 847     outLen = uidna_IDNToUnicode(invalid_idn, len, output, 50, UIDNA_USE_STD3_RULES, &prsError, &status);
 848     if(U_FAILURE(status)){
 849         log_err_status(status, "uidna_toUnicode failed with error: %s\n", u_errorName(status));
 850     }
 851 }
 852
 853 /*
 854  * Test the new (ICU 4.6/2010) C API that was added for UTS #46.
 855  * Just an API test: Functionality is tested via C++ intltest.
 856  */
 857 static void TestUTS46() {
 858     static const UChar fA_sharps16[] = { 0x66, 0x41, 0xdf, 0 };
 859     static const char fA_sharps8[] = { 0x66, 0x41, (char)0xc3, (char)0x9f, 0 };
 860     static const UChar fa_sharps16[] = { 0x66, 0x61, 0xdf, 0 };
 861     static const char fa_sharps8[] = { 0x66, 0x61, (char)0xc3, (char)0x9f, 0 };
 862     static const UChar fass16[] = { 0x66, 0x61, 0x73, 0x73, 0 };
 863     static const char fass8[] = { 0x66, 0x61, 0x73, 0x73, 0 };
 864     static const UChar fA_BEL[] = { 0x66, 0x41, 7, 0 };
 865     static const UChar fa_FFFD[] = { 0x66, 0x61, 0xfffd, 0 };
 866
 867     UChar dest16[10];
 868     char dest8[10];
 869     int32_t length;
 870
 871     UIDNAInfo info = UIDNA_INFO_INITIALIZER;
 872     UErrorCode errorCode = U_ZERO_ERROR;
 873     UIDNA *uts46 = uidna_openUTS46(UIDNA_USE_STD3_RULES|UIDNA_NONTRANSITIONAL_TO_UNICODE,
 874                                    &errorCode);
 875     if(U_FAILURE(errorCode)) {
 876         log_err_status(errorCode, "uidna_openUTS46() failed: %s\n", u_errorName(errorCode));
 877         return;
 878     }
 879
 880     /* These calls should succeed. */
 881     length = uidna_labelToASCII(uts46, fA_sharps16, -1,
 882                                 dest16, UPRV_LENGTHOF(dest16), &info, &errorCode);
 883     if( U_FAILURE(errorCode) || length != 4 || 0 != u_memcmp(dest16, fass16, 5) ||
 884         !info.isTransitionalDifferent || info.errors != 0
 885     ) {
 886         log_err("uidna_labelToASCII() failed: %s\n", u_errorName(errorCode));
 887     }
 888     errorCode = U_ZERO_ERROR;
 889     length = uidna_labelToUnicode(uts46, fA_sharps16, u_strlen(fA_sharps16),
 890                                   dest16, UPRV_LENGTHOF(dest16), &info, &errorCode);
 891     if( U_FAILURE(errorCode) || length != 3 || 0 != u_memcmp(dest16, fa_sharps16, 4) ||
 892         !info.isTransitionalDifferent || info.errors != 0
 893     ) {
 894         log_err("uidna_labelToUnicode() failed: %s\n", u_errorName(errorCode));
 895     }
 896     errorCode = U_ZERO_ERROR;
 897     length = uidna_nameToASCII(uts46, fA_sharps16, u_strlen(fA_sharps16),
 898                                dest16, 4, &info, &errorCode);
 899     if( errorCode != U_STRING_NOT_TERMINATED_WARNING ||
 900         length != 4 || 0 != u_memcmp(dest16, fass16, 4) ||
 901         !info.isTransitionalDifferent || info.errors != 0
 902     ) {
 903         log_err("uidna_nameToASCII() failed: %s\n", u_errorName(errorCode));
 904     }
 905     errorCode = U_ZERO_ERROR;
 906     length = uidna_nameToUnicode(uts46, fA_sharps16, -1,
 907                                  dest16, 3, &info, &errorCode);
 908     if( errorCode != U_STRING_NOT_TERMINATED_WARNING ||
 909         length != 3 || 0 != u_memcmp(dest16, fa_sharps16, 3) ||
 910         !info.isTransitionalDifferent || info.errors != 0
 911     ) {
 912         log_err("uidna_nameToUnicode() failed: %s\n", u_errorName(errorCode));
 913     }
 914
 915     errorCode = U_ZERO_ERROR;
 916     length = uidna_labelToASCII_UTF8(uts46, fA_sharps8, -1,
 917                                      dest8, UPRV_LENGTHOF(dest8), &info, &errorCode);
 918     if( U_FAILURE(errorCode) || length != 4 || 0 != memcmp(dest8, fass8, 5) ||
 919         !info.isTransitionalDifferent || info.errors != 0
 920     ) {
 921         log_err("uidna_labelToASCII_UTF8() failed: %s\n", u_errorName(errorCode));
 922     }
 923     errorCode = U_ZERO_ERROR;
 924     length = uidna_labelToUnicodeUTF8(uts46, fA_sharps8, strlen(fA_sharps8),
 925                                       dest8, UPRV_LENGTHOF(dest8), &info, &errorCode);
 926     if( U_FAILURE(errorCode) || length != 4 || 0 != memcmp(dest8, fa_sharps8, 5) ||
 927         !info.isTransitionalDifferent || info.errors != 0
 928     ) {
 929         log_err("uidna_labelToUnicodeUTF8() failed: %s\n", u_errorName(errorCode));
 930     }
 931     errorCode = U_ZERO_ERROR;
 932     length = uidna_nameToASCII_UTF8(uts46, fA_sharps8, strlen(fA_sharps8),
 933                                     dest8, 4, &info, &errorCode);
 934     if( errorCode != U_STRING_NOT_TERMINATED_WARNING ||
 935         length != 4 || 0 != memcmp(dest8, fass8, 4) ||
 936         !info.isTransitionalDifferent || info.errors != 0
 937     ) {
 938         log_err("uidna_nameToASCII_UTF8() failed: %s\n", u_errorName(errorCode));
 939     }
 940     errorCode = U_ZERO_ERROR;
 941     length = uidna_nameToUnicodeUTF8(uts46, fA_sharps8, -1,
 942                                      dest8, 4, &info, &errorCode);
 943     if( errorCode != U_STRING_NOT_TERMINATED_WARNING ||
 944         length != 4 || 0 != memcmp(dest8, fa_sharps8, 4) ||
 945         !info.isTransitionalDifferent || info.errors != 0
 946     ) {
 947         log_err("uidna_nameToUnicodeUTF8() failed: %s\n", u_errorName(errorCode));
 948     }
 949
 950     errorCode = U_ZERO_ERROR;
 951     length = uidna_nameToASCII(uts46, NULL, 0,
 952                                dest16, 0, &info, &errorCode);
 953     if( errorCode != U_STRING_NOT_TERMINATED_WARNING ||
 954         length != 0 ||
 955         info.isTransitionalDifferent || info.errors != UIDNA_ERROR_EMPTY_LABEL
 956     ) {
 957         log_err("uidna_nameToASCII(empty) failed: %s\n", u_errorName(errorCode));
 958     }
 959     errorCode = U_ZERO_ERROR;
 960     length = uidna_nameToUnicode(uts46, fA_BEL, -1,
 961                                  dest16, 3, &info, &errorCode);
 962     if( errorCode != U_STRING_NOT_TERMINATED_WARNING ||
 963         length != 3 || 0 != u_memcmp(dest16, fa_FFFD, 3) ||
 964         info.isTransitionalDifferent || info.errors == 0
 965     ) {
 966         log_err("uidna_nameToUnicode(fa<BEL>) failed: %s\n", u_errorName(errorCode));
 967     }
 968
 969     /* These calls should fail. */
 970     errorCode = U_USELESS_COLLATOR_ERROR;
 971     length = uidna_labelToASCII(uts46, fA_sharps16, -1,
 972                                 dest16, UPRV_LENGTHOF(dest16), &info, &errorCode);
 973     if(errorCode != U_USELESS_COLLATOR_ERROR) {
 974         log_err("uidna_labelToASCII(failure) failed: %s\n", u_errorName(errorCode));
 975     }
 976     errorCode = U_ZERO_ERROR;
 977     length = uidna_labelToUnicode(uts46, fA_sharps16, u_strlen(fA_sharps16),
 978                                   dest16, UPRV_LENGTHOF(dest16), NULL, &errorCode);
 979     if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
 980         log_err("uidna_labelToUnicode(UIDNAInfo=NULL) failed: %s\n", u_errorName(errorCode));
 981     }
 982     errorCode = U_ZERO_ERROR;
 983     length = uidna_nameToASCII(uts46, NULL, u_strlen(fA_sharps16),
 984                                dest16, 4, &info, &errorCode);
 985     if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
 986         log_err("uidna_nameToASCII(src=NULL) failed: %s\n", u_errorName(errorCode));
 987     }
 988     errorCode = U_ZERO_ERROR;
 989     length = uidna_nameToUnicode(uts46, fA_sharps16, -2,
 990                                  dest16, 3, &info, &errorCode);
 991     if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
 992         log_err("uidna_nameToUnicode(length<-1) failed: %s\n", u_errorName(errorCode));
 993     }
 994
 995     errorCode = U_ZERO_ERROR;
 996     length = uidna_labelToASCII_UTF8(uts46, fA_sharps8, -1,
 997                                      NULL, UPRV_LENGTHOF(dest8), &info, &errorCode);
 998     if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
 999         log_err("uidna_labelToASCII_UTF8(dest=NULL) failed: %s\n", u_errorName(errorCode));
1000     }
1001     errorCode = U_ZERO_ERROR;
1002     length = uidna_labelToUnicodeUTF8(uts46, fA_sharps8, strlen(fA_sharps8),
1003                                       dest8, -1, &info, &errorCode);
1004     if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
1005         log_err("uidna_labelToUnicodeUTF8(capacity<0) failed: %s\n", u_errorName(errorCode));
1006     }
1007     errorCode = U_ZERO_ERROR;
1008     length = uidna_nameToASCII_UTF8(uts46, dest8, strlen(fA_sharps8),
1009                                     dest8, 4, &info, &errorCode);
1010     if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
1011         log_err("uidna_nameToASCII_UTF8(src==dest!=NULL) failed: %s\n", u_errorName(errorCode));
1012     }
1013     errorCode = U_ZERO_ERROR;
1014     length = uidna_nameToUnicodeUTF8(uts46, fA_sharps8, -1,
1015                                      dest8, 3, &info, &errorCode);
1016     if(errorCode != U_BUFFER_OVERFLOW_ERROR || length != 4) {
1017         log_err("uidna_nameToUnicodeUTF8() overflow failed: %s\n", u_errorName(errorCode));
1018     }
1019
1020     uidna_close(uts46);
1021 }
1022
1023 #endif
1024
1025 /*
1026  * Hey, Emacs, please set the following:
1027  *
1028  * Local Variables:
1029  * indent-tabs-mode: nil
1030  * End:
1031  *
1032  */