icuSources/test/intltest/uts46test.cpp

   1 /*
   2 *******************************************************************************
   3 *   Copyright (C) 2010-2014, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 *******************************************************************************
   6 *   file name:  uts46test.cpp
   7 *   encoding:   US-ASCII
   8 *   tab size:   8 (not used)
   9 *   indentation:4
  10 *
  11 *   created on: 2010may05
  12 *   created by: Markus W. Scherer
  13 */
  14
  15 #include "unicode/utypes.h"
  16
  17 #if !UCONFIG_NO_IDNA
  18
  19 #include <string.h>
  20 #include "unicode/bytestream.h"
  21 #include "unicode/idna.h"
  22 #include "unicode/localpointer.h"
  23 #include "unicode/std_string.h"
  24 #include "unicode/stringpiece.h"
  25 #include "unicode/uidna.h"
  26 #include "unicode/unistr.h"
  27 #include "intltest.h"
  28
  29 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
  30
  31 class UTS46Test : public IntlTest {
  32 public:
  33     UTS46Test() : trans(NULL), nontrans(NULL) {}
  34     virtual ~UTS46Test();
  35
  36     void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=NULL);
  37     void TestAPI();
  38     void TestNotSTD3();
  39     void TestSomeCases();
  40 private:
  41     IDNA *trans, *nontrans;
  42 };
  43
  44 extern IntlTest *createUTS46Test() {
  45     return new UTS46Test();
  46 }
  47
  48 UTS46Test::~UTS46Test() {
  49     delete trans;
  50     delete nontrans;
  51 }
  52
  53 void UTS46Test::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) {
  54     if(exec) {
  55         logln("TestSuite UTS46Test: ");
  56         if(trans==NULL) {
  57             IcuTestErrorCode errorCode(*this, "init/createUTS46Instance()");
  58             uint32_t commonOptions=
  59                 UIDNA_USE_STD3_RULES|UIDNA_CHECK_BIDI|
  60                 UIDNA_CHECK_CONTEXTJ|UIDNA_CHECK_CONTEXTO;
  61             trans=IDNA::createUTS46Instance(commonOptions, errorCode);
  62             nontrans=IDNA::createUTS46Instance(
  63                 commonOptions|
  64                 UIDNA_NONTRANSITIONAL_TO_ASCII|UIDNA_NONTRANSITIONAL_TO_UNICODE,
  65                 errorCode);
  66             if(errorCode.logDataIfFailureAndReset("createUTS46Instance()")) {
  67                 name="";
  68                 return;
  69             }
  70         }
  71     }
  72     TESTCASE_AUTO_BEGIN;
  73     TESTCASE_AUTO(TestAPI);
  74     TESTCASE_AUTO(TestNotSTD3);
  75     TESTCASE_AUTO(TestSomeCases);
  76     TESTCASE_AUTO_END;
  77 }
  78
  79 const uint32_t severeErrors=
  80     UIDNA_ERROR_LEADING_COMBINING_MARK|
  81     UIDNA_ERROR_DISALLOWED|
  82     UIDNA_ERROR_PUNYCODE|
  83     UIDNA_ERROR_LABEL_HAS_DOT|
  84     UIDNA_ERROR_INVALID_ACE_LABEL;
  85
  86 static UBool isASCII(const UnicodeString &str) {
  87     const UChar *s=str.getBuffer();
  88     int32_t length=str.length();
  89     for(int32_t i=0; i<length; ++i) {
  90         if(s[i]>=0x80) {
  91             return FALSE;
  92         }
  93     }
  94     return TRUE;
  95 }
  96
  97 class TestCheckedArrayByteSink : public CheckedArrayByteSink {
  98 public:
  99     TestCheckedArrayByteSink(char* outbuf, int32_t capacity)
 100             : CheckedArrayByteSink(outbuf, capacity), calledFlush(FALSE) {}
 101     virtual CheckedArrayByteSink& Reset() {
 102         CheckedArrayByteSink::Reset();
 103         calledFlush = FALSE;
 104         return *this;
 105     }
 106     virtual void Flush() { calledFlush = TRUE; }
 107     UBool calledFlush;
 108 };
 109
 110 void UTS46Test::TestAPI() {
 111     UErrorCode errorCode=U_ZERO_ERROR;
 112     UnicodeString result;
 113     IDNAInfo info;
 114     UnicodeString input=UNICODE_STRING_SIMPLE("www.eXample.cOm");
 115     UnicodeString expected=UNICODE_STRING_SIMPLE("www.example.com");
 116     trans->nameToASCII(input, result, info, errorCode);
 117     if(U_FAILURE(errorCode) || info.hasErrors() || result!=expected) {
 118         errln("T.nameToASCII(www.example.com) info.errors=%04lx result matches=%d %s",
 119               (long)info.getErrors(), result==expected, u_errorName(errorCode));
 120     }
 121     errorCode=U_USELESS_COLLATOR_ERROR;
 122     trans->nameToUnicode(input, result, info, errorCode);
 123     if(errorCode!=U_USELESS_COLLATOR_ERROR || !result.isBogus()) {
 124         errln("T.nameToUnicode(U_FAILURE) did not preserve the errorCode "
 125               "or not result.setToBogus() - %s",
 126               u_errorName(errorCode));
 127     }
 128     errorCode=U_ZERO_ERROR;
 129     input.setToBogus();
 130     result=UNICODE_STRING_SIMPLE("quatsch");
 131     nontrans->labelToASCII(input, result, info, errorCode);
 132     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || !result.isBogus()) {
 133         errln("N.labelToASCII(bogus) did not set illegal-argument-error "
 134               "or not result.setToBogus() - %s",
 135               u_errorName(errorCode));
 136     }
 137     errorCode=U_ZERO_ERROR;
 138     input=UNICODE_STRING_SIMPLE("xn--bcher.de-65a");
 139     expected=UNICODE_STRING_SIMPLE("xn--bcher\\uFFFDde-65a").unescape();
 140     nontrans->labelToASCII(input, result, info, errorCode);
 141     if( U_FAILURE(errorCode) ||
 142         info.getErrors()!=(UIDNA_ERROR_LABEL_HAS_DOT|UIDNA_ERROR_INVALID_ACE_LABEL) ||
 143         result!=expected
 144     ) {
 145         errln("N.labelToASCII(label-with-dot) failed with errors %04lx - %s",
 146               info.getErrors(), u_errorName(errorCode));
 147     }
 148     // UTF-8
 149     char buffer[100];
 150     TestCheckedArrayByteSink sink(buffer, LENGTHOF(buffer));
 151     errorCode=U_ZERO_ERROR;
 152     nontrans->labelToUnicodeUTF8(StringPiece(NULL, 5), sink, info, errorCode);
 153     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || sink.NumberOfBytesWritten()!=0) {
 154         errln("N.labelToUnicodeUTF8(StringPiece(NULL, 5)) did not set illegal-argument-error ",
 155               "or did output something - %s",
 156               u_errorName(errorCode));
 157     }
 158
 159     sink.Reset();
 160     errorCode=U_ZERO_ERROR;
 161     nontrans->nameToASCII_UTF8(StringPiece(), sink, info, errorCode);
 162     if(U_FAILURE(errorCode) || sink.NumberOfBytesWritten()!=0 || !sink.calledFlush) {
 163         errln("N.nameToASCII_UTF8(empty) failed - %s",
 164               u_errorName(errorCode));
 165     }
 166
 167     static const char s[]={ 0x61, (char)0xc3, (char)0x9f };
 168     sink.Reset();
 169     errorCode=U_USELESS_COLLATOR_ERROR;
 170     nontrans->nameToUnicodeUTF8(StringPiece(s, 3), sink, info, errorCode);
 171     if(errorCode!=U_USELESS_COLLATOR_ERROR || sink.NumberOfBytesWritten()!=0) {
 172         errln("N.nameToUnicode_UTF8(U_FAILURE) did not preserve the errorCode "
 173               "or did output something - %s",
 174               u_errorName(errorCode));
 175     }
 176
 177     sink.Reset();
 178     errorCode=U_ZERO_ERROR;
 179     trans->labelToUnicodeUTF8(StringPiece(s, 3), sink, info, errorCode);
 180     if( U_FAILURE(errorCode) || sink.NumberOfBytesWritten()!=3 ||
 181         buffer[0]!=0x61 || buffer[1]!=0x73 || buffer[2]!=0x73 ||
 182         !sink.calledFlush
 183     ) {
 184         errln("T.labelToUnicodeUTF8(a sharp-s) failed - %s",
 185               u_errorName(errorCode));
 186     }
 187
 188     sink.Reset();
 189     errorCode=U_ZERO_ERROR;
 190     // "eXampLe.cOm"
 191     static const char eX[]={ 0x65, 0x58, 0x61, 0x6d, 0x70, 0x4c, 0x65, 0x2e, 0x63, 0x4f, 0x6d, 0 };
 192     // "example.com"
 193     static const char ex[]={ 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d };
 194     trans->nameToUnicodeUTF8(eX, sink, info, errorCode);
 195     if( U_FAILURE(errorCode) || sink.NumberOfBytesWritten()!=11 ||
 196         0!=memcmp(ex, buffer, 11) || !sink.calledFlush
 197     ) {
 198         errln("T.nameToUnicodeUTF8(eXampLe.cOm) failed - %s",
 199               u_errorName(errorCode));
 200     }
 201 }
 202
 203 void UTS46Test::TestNotSTD3() {
 204     IcuTestErrorCode errorCode(*this, "TestNotSTD3()");
 205     char buffer[400];
 206     LocalPointer<IDNA> not3(IDNA::createUTS46Instance(UIDNA_CHECK_BIDI, errorCode));
 207     if(errorCode.isFailure()) {
 208         return;
 209     }
 210     UnicodeString input=UNICODE_STRING_SIMPLE("\\u0000A_2+2=4\\u000A.e\\u00DFen.net").unescape();
 211     UnicodeString result;
 212     IDNAInfo info;
 213     if( not3->nameToUnicode(input, result, info, errorCode)!=
 214             UNICODE_STRING_SIMPLE("\\u0000a_2+2=4\\u000A.essen.net").unescape() ||
 215         info.hasErrors()
 216     ) {
 217         prettify(result).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 218         errln("notSTD3.nameToUnicode(non-LDH ASCII) unexpected errors %04lx string %s",
 219               (long)info.getErrors(), buffer);
 220     }
 221     // A space (BiDi class WS) is not allowed in a BiDi domain name.
 222     input=UNICODE_STRING_SIMPLE("a z.xn--4db.edu");
 223     not3->nameToASCII(input, result, info, errorCode);
 224     if(result!=input || info.getErrors()!=UIDNA_ERROR_BIDI) {
 225         errln("notSTD3.nameToASCII(ASCII-with-space.alef.edu) failed");
 226     }
 227     // Characters that are canonically equivalent to sequences with non-LDH ASCII.
 228     input=UNICODE_STRING_SIMPLE("a\\u2260b\\u226Ec\\u226Fd").unescape();
 229     not3->nameToUnicode(input, result, info, errorCode);
 230     if(result!=input || info.hasErrors()) {
 231         prettify(result).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 232         errln("notSTD3.nameToUnicode(equiv to non-LDH ASCII) unexpected errors %04lx string %s",
 233               (long)info.getErrors(), buffer);
 234     }
 235 }
 236
 237 struct TestCase {
 238     // Input string and options string (Nontransitional/Transitional/Both).
 239     const char *s, *o;
 240     // Expected Unicode result string.
 241     const char *u;
 242     uint32_t errors;
 243 };
 244
 245 static const TestCase testCases[]={
 246     { "www.eXample.cOm", "B",  // all ASCII
 247       "www.example.com", 0 },
 248     { "B\\u00FCcher.de", "B",  // u-umlaut
 249       "b\\u00FCcher.de", 0 },
 250     { "\\u00D6BB", "B",  // O-umlaut
 251       "\\u00F6bb", 0 },
 252     { "fa\\u00DF.de", "N",  // sharp s
 253       "fa\\u00DF.de", 0 },
 254     { "fa\\u00DF.de", "T",  // sharp s
 255       "fass.de", 0 },
 256     { "XN--fA-hia.dE", "B",  // sharp s in Punycode
 257       "fa\\u00DF.de", 0 },
 258     { "\\u03B2\\u03CC\\u03BB\\u03BF\\u03C2.com", "N",  // Greek with final sigma
 259       "\\u03B2\\u03CC\\u03BB\\u03BF\\u03C2.com", 0 },
 260     { "\\u03B2\\u03CC\\u03BB\\u03BF\\u03C2.com", "T",  // Greek with final sigma
 261       "\\u03B2\\u03CC\\u03BB\\u03BF\\u03C3.com", 0 },
 262     { "xn--nxasmm1c", "B",  // Greek with final sigma in Punycode
 263       "\\u03B2\\u03CC\\u03BB\\u03BF\\u03C2", 0 },
 264     { "www.\\u0DC1\\u0DCA\\u200D\\u0DBB\\u0DD3.com", "N",  // "Sri" in "Sri Lanka" has a ZWJ
 265       "www.\\u0DC1\\u0DCA\\u200D\\u0DBB\\u0DD3.com", 0 },
 266     { "www.\\u0DC1\\u0DCA\\u200D\\u0DBB\\u0DD3.com", "T",  // "Sri" in "Sri Lanka" has a ZWJ
 267       "www.\\u0DC1\\u0DCA\\u0DBB\\u0DD3.com", 0 },
 268     { "www.xn--10cl1a0b660p.com", "B",  // "Sri" in Punycode
 269       "www.\\u0DC1\\u0DCA\\u200D\\u0DBB\\u0DD3.com", 0 },
 270     { "\\u0646\\u0627\\u0645\\u0647\\u200C\\u0627\\u06CC", "N",  // ZWNJ
 271       "\\u0646\\u0627\\u0645\\u0647\\u200C\\u0627\\u06CC", 0 },
 272     { "\\u0646\\u0627\\u0645\\u0647\\u200C\\u0627\\u06CC", "T",  // ZWNJ
 273       "\\u0646\\u0627\\u0645\\u0647\\u0627\\u06CC", 0 },
 274     { "xn--mgba3gch31f060k.com", "B",  // ZWNJ in Punycode
 275       "\\u0646\\u0627\\u0645\\u0647\\u200C\\u0627\\u06CC.com", 0 },
 276     { "a.b\\uFF0Ec\\u3002d\\uFF61", "B",
 277       "a.b.c.d.", 0 },
 278     { "U\\u0308.xn--tda", "B",  // U+umlaut.u-umlaut
 279       "\\u00FC.\\u00FC", 0 },
 280     { "xn--u-ccb", "B",  // u+umlaut in Punycode
 281       "xn--u-ccb\\uFFFD", UIDNA_ERROR_INVALID_ACE_LABEL },
 282     { "a\\u2488com", "B",  // contains 1-dot
 283       "a\\uFFFDcom", UIDNA_ERROR_DISALLOWED },
 284     { "xn--a-ecp.ru", "B",  // contains 1-dot in Punycode
 285       "xn--a-ecp\\uFFFD.ru", UIDNA_ERROR_INVALID_ACE_LABEL },
 286     { "xn--0.pt", "B",  // invalid Punycode
 287       "xn--0\\uFFFD.pt", UIDNA_ERROR_PUNYCODE },
 288     { "xn--a.pt", "B",  // U+0080
 289       "xn--a\\uFFFD.pt", UIDNA_ERROR_INVALID_ACE_LABEL },
 290     { "xn--a-\\u00C4.pt", "B",  // invalid Punycode
 291       "xn--a-\\u00E4.pt", UIDNA_ERROR_PUNYCODE },
 292     { "\\u65E5\\u672C\\u8A9E\\u3002\\uFF2A\\uFF30", "B",  // Japanese with fullwidth ".jp"
 293       "\\u65E5\\u672C\\u8A9E.jp", 0 },
 294     { "\\u2615", "B", "\\u2615", 0 },  // Unicode 4.0 HOT BEVERAGE
 295     // some characters are disallowed because they are canonically equivalent
 296     // to sequences with non-LDH ASCII
 297     { "a\\u2260b\\u226Ec\\u226Fd", "B",
 298       "a\\uFFFDb\\uFFFDc\\uFFFDd", UIDNA_ERROR_DISALLOWED },
 299     // many deviation characters, test the special mapping code
 300     { "1.a\\u00DF\\u200C\\u200Db\\u200C\\u200Dc\\u00DF\\u00DF\\u00DF\\u00DFd"
 301       "\\u03C2\\u03C3\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DFe"
 302       "\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DFx"
 303       "\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DFy"
 304       "\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u0302\\u00DFz", "N",
 305       "1.a\\u00DF\\u200C\\u200Db\\u200C\\u200Dc\\u00DF\\u00DF\\u00DF\\u00DFd"
 306       "\\u03C2\\u03C3\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DFe"
 307       "\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DFx"
 308       "\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DFy"
 309       "\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u0302\\u00DFz",
 310       UIDNA_ERROR_LABEL_TOO_LONG|UIDNA_ERROR_CONTEXTJ },
 311     { "1.a\\u00DF\\u200C\\u200Db\\u200C\\u200Dc\\u00DF\\u00DF\\u00DF\\u00DFd"
 312       "\\u03C2\\u03C3\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DFe"
 313       "\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DFx"
 314       "\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DFy"
 315       "\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u00DF\\u0302\\u00DFz", "T",
 316       "1.assbcssssssssd"
 317       "\\u03C3\\u03C3sssssssssssssssse"
 318       "ssssssssssssssssssssx"
 319       "ssssssssssssssssssssy"
 320       "sssssssssssssss\\u015Dssz", UIDNA_ERROR_LABEL_TOO_LONG },
 321     // "xn--bss" with deviation characters
 322     { "\\u200Cx\\u200Dn\\u200C-\\u200D-b\\u00DF", "N",
 323       "\\u200Cx\\u200Dn\\u200C-\\u200D-b\\u00DF", UIDNA_ERROR_CONTEXTJ },
 324     { "\\u200Cx\\u200Dn\\u200C-\\u200D-b\\u00DF", "T",
 325       "\\u5919", 0 },
 326     // "xn--bssffl" written as:
 327     // 02E3 MODIFIER LETTER SMALL X
 328     // 034F COMBINING GRAPHEME JOINER (ignored)
 329     // 2115 DOUBLE-STRUCK CAPITAL N
 330     // 200B ZERO WIDTH SPACE (ignored)
 331     // FE63 SMALL HYPHEN-MINUS
 332     // 00AD SOFT HYPHEN (ignored)
 333     // FF0D FULLWIDTH HYPHEN-MINUS
 334     // 180C MONGOLIAN FREE VARIATION SELECTOR TWO (ignored)
 335     // 212C SCRIPT CAPITAL B
 336     // FE00 VARIATION SELECTOR-1 (ignored)
 337     // 017F LATIN SMALL LETTER LONG S
 338     // 2064 INVISIBLE PLUS (ignored)
 339     // 1D530 MATHEMATICAL FRAKTUR SMALL S
 340     // E01EF VARIATION SELECTOR-256 (ignored)
 341     // FB04 LATIN SMALL LIGATURE FFL
 342     { "\\u02E3\\u034F\\u2115\\u200B\\uFE63\\u00AD\\uFF0D\\u180C"
 343       "\\u212C\\uFE00\\u017F\\u2064\\U0001D530\\U000E01EF\\uFB04", "B",
 344       "\\u5921\\u591E\\u591C\\u5919", 0 },
 345     { "123456789012345678901234567890123456789012345678901234567890123."
 346       "123456789012345678901234567890123456789012345678901234567890123."
 347       "123456789012345678901234567890123456789012345678901234567890123."
 348       "1234567890123456789012345678901234567890123456789012345678901", "B",
 349       "123456789012345678901234567890123456789012345678901234567890123."
 350       "123456789012345678901234567890123456789012345678901234567890123."
 351       "123456789012345678901234567890123456789012345678901234567890123."
 352       "1234567890123456789012345678901234567890123456789012345678901", 0 },
 353     { "123456789012345678901234567890123456789012345678901234567890123."
 354       "123456789012345678901234567890123456789012345678901234567890123."
 355       "123456789012345678901234567890123456789012345678901234567890123."
 356       "1234567890123456789012345678901234567890123456789012345678901.", "B",
 357       "123456789012345678901234567890123456789012345678901234567890123."
 358       "123456789012345678901234567890123456789012345678901234567890123."
 359       "123456789012345678901234567890123456789012345678901234567890123."
 360       "1234567890123456789012345678901234567890123456789012345678901.", 0 },
 361     // Domain name >256 characters, forces slow path in UTF-8 processing.
 362     { "123456789012345678901234567890123456789012345678901234567890123."
 363       "123456789012345678901234567890123456789012345678901234567890123."
 364       "123456789012345678901234567890123456789012345678901234567890123."
 365       "123456789012345678901234567890123456789012345678901234567890123."
 366       "12345678901234567890123456789012345678901234567890123456789012", "B",
 367       "123456789012345678901234567890123456789012345678901234567890123."
 368       "123456789012345678901234567890123456789012345678901234567890123."
 369       "123456789012345678901234567890123456789012345678901234567890123."
 370       "123456789012345678901234567890123456789012345678901234567890123."
 371       "12345678901234567890123456789012345678901234567890123456789012",
 372       UIDNA_ERROR_DOMAIN_NAME_TOO_LONG },
 373     { "123456789012345678901234567890123456789012345678901234567890123."
 374       "123456789012345678901234567890123456789012345678901234567890123."
 375       "123456789012345678901234567890123456789012345678901234567890123."
 376       "123456789012345678901234567890123456789012345678901234567890123."
 377       "1234567890123456789012345678901234567890123456789\\u05D0", "B",
 378       "123456789012345678901234567890123456789012345678901234567890123."
 379       "123456789012345678901234567890123456789012345678901234567890123."
 380       "123456789012345678901234567890123456789012345678901234567890123."
 381       "123456789012345678901234567890123456789012345678901234567890123."
 382       "1234567890123456789012345678901234567890123456789\\u05D0",
 383       UIDNA_ERROR_DOMAIN_NAME_TOO_LONG|UIDNA_ERROR_BIDI },
 384     { "123456789012345678901234567890123456789012345678901234567890123."
 385       "1234567890123456789012345678901234567890123456789012345678901234."
 386       "123456789012345678901234567890123456789012345678901234567890123."
 387       "123456789012345678901234567890123456789012345678901234567890", "B",
 388       "123456789012345678901234567890123456789012345678901234567890123."
 389       "1234567890123456789012345678901234567890123456789012345678901234."
 390       "123456789012345678901234567890123456789012345678901234567890123."
 391       "123456789012345678901234567890123456789012345678901234567890",
 392       UIDNA_ERROR_LABEL_TOO_LONG },
 393     { "123456789012345678901234567890123456789012345678901234567890123."
 394       "1234567890123456789012345678901234567890123456789012345678901234."
 395       "123456789012345678901234567890123456789012345678901234567890123."
 396       "123456789012345678901234567890123456789012345678901234567890.", "B",
 397       "123456789012345678901234567890123456789012345678901234567890123."
 398       "1234567890123456789012345678901234567890123456789012345678901234."
 399       "123456789012345678901234567890123456789012345678901234567890123."
 400       "123456789012345678901234567890123456789012345678901234567890.",
 401       UIDNA_ERROR_LABEL_TOO_LONG },
 402     { "123456789012345678901234567890123456789012345678901234567890123."
 403       "1234567890123456789012345678901234567890123456789012345678901234."
 404       "123456789012345678901234567890123456789012345678901234567890123."
 405       "1234567890123456789012345678901234567890123456789012345678901", "B",
 406       "123456789012345678901234567890123456789012345678901234567890123."
 407       "1234567890123456789012345678901234567890123456789012345678901234."
 408       "123456789012345678901234567890123456789012345678901234567890123."
 409       "1234567890123456789012345678901234567890123456789012345678901",
 410       UIDNA_ERROR_LABEL_TOO_LONG|UIDNA_ERROR_DOMAIN_NAME_TOO_LONG },
 411     // label length 63: xn--1234567890123456789012345678901234567890123456789012345-9te
 412     { "\\u00E41234567890123456789012345678901234567890123456789012345", "B",
 413       "\\u00E41234567890123456789012345678901234567890123456789012345", 0 },
 414     { "1234567890\\u00E41234567890123456789012345678901234567890123456", "B",
 415       "1234567890\\u00E41234567890123456789012345678901234567890123456", UIDNA_ERROR_LABEL_TOO_LONG },
 416     { "123456789012345678901234567890123456789012345678901234567890123."
 417       "1234567890\\u00E4123456789012345678901234567890123456789012345."
 418       "123456789012345678901234567890123456789012345678901234567890123."
 419       "1234567890123456789012345678901234567890123456789012345678901", "B",
 420       "123456789012345678901234567890123456789012345678901234567890123."
 421       "1234567890\\u00E4123456789012345678901234567890123456789012345."
 422       "123456789012345678901234567890123456789012345678901234567890123."
 423       "1234567890123456789012345678901234567890123456789012345678901", 0 },
 424     { "123456789012345678901234567890123456789012345678901234567890123."
 425       "1234567890\\u00E4123456789012345678901234567890123456789012345."
 426       "123456789012345678901234567890123456789012345678901234567890123."
 427       "1234567890123456789012345678901234567890123456789012345678901.", "B",
 428       "123456789012345678901234567890123456789012345678901234567890123."
 429       "1234567890\\u00E4123456789012345678901234567890123456789012345."
 430       "123456789012345678901234567890123456789012345678901234567890123."
 431       "1234567890123456789012345678901234567890123456789012345678901.", 0 },
 432     { "123456789012345678901234567890123456789012345678901234567890123."
 433       "1234567890\\u00E4123456789012345678901234567890123456789012345."
 434       "123456789012345678901234567890123456789012345678901234567890123."
 435       "12345678901234567890123456789012345678901234567890123456789012", "B",
 436       "123456789012345678901234567890123456789012345678901234567890123."
 437       "1234567890\\u00E4123456789012345678901234567890123456789012345."
 438       "123456789012345678901234567890123456789012345678901234567890123."
 439       "12345678901234567890123456789012345678901234567890123456789012",
 440       UIDNA_ERROR_DOMAIN_NAME_TOO_LONG },
 441     { "123456789012345678901234567890123456789012345678901234567890123."
 442       "1234567890\\u00E41234567890123456789012345678901234567890123456."
 443       "123456789012345678901234567890123456789012345678901234567890123."
 444       "123456789012345678901234567890123456789012345678901234567890", "B",
 445       "123456789012345678901234567890123456789012345678901234567890123."
 446       "1234567890\\u00E41234567890123456789012345678901234567890123456."
 447       "123456789012345678901234567890123456789012345678901234567890123."
 448       "123456789012345678901234567890123456789012345678901234567890",
 449       UIDNA_ERROR_LABEL_TOO_LONG },
 450     { "123456789012345678901234567890123456789012345678901234567890123."
 451       "1234567890\\u00E41234567890123456789012345678901234567890123456."
 452       "123456789012345678901234567890123456789012345678901234567890123."
 453       "123456789012345678901234567890123456789012345678901234567890.", "B",
 454       "123456789012345678901234567890123456789012345678901234567890123."
 455       "1234567890\\u00E41234567890123456789012345678901234567890123456."
 456       "123456789012345678901234567890123456789012345678901234567890123."
 457       "123456789012345678901234567890123456789012345678901234567890.",
 458       UIDNA_ERROR_LABEL_TOO_LONG },
 459     { "123456789012345678901234567890123456789012345678901234567890123."
 460       "1234567890\\u00E41234567890123456789012345678901234567890123456."
 461       "123456789012345678901234567890123456789012345678901234567890123."
 462       "1234567890123456789012345678901234567890123456789012345678901", "B",
 463       "123456789012345678901234567890123456789012345678901234567890123."
 464       "1234567890\\u00E41234567890123456789012345678901234567890123456."
 465       "123456789012345678901234567890123456789012345678901234567890123."
 466       "1234567890123456789012345678901234567890123456789012345678901",
 467       UIDNA_ERROR_LABEL_TOO_LONG|UIDNA_ERROR_DOMAIN_NAME_TOO_LONG },
 468     // hyphen errors and empty-label errors
 469     { ".", "B", ".", UIDNA_ERROR_EMPTY_LABEL },
 470     { "\\uFF0E", "B", ".", UIDNA_ERROR_EMPTY_LABEL },
 471     // "xn---q----jra"=="-q--a-umlaut-"
 472     { "a.b..-q--a-.e", "B", "a.b..-q--a-.e",
 473       UIDNA_ERROR_EMPTY_LABEL|UIDNA_ERROR_LEADING_HYPHEN|UIDNA_ERROR_TRAILING_HYPHEN|
 474       UIDNA_ERROR_HYPHEN_3_4 },
 475     { "a.b..-q--\\u00E4-.e", "B", "a.b..-q--\\u00E4-.e",
 476       UIDNA_ERROR_EMPTY_LABEL|UIDNA_ERROR_LEADING_HYPHEN|UIDNA_ERROR_TRAILING_HYPHEN|
 477       UIDNA_ERROR_HYPHEN_3_4 },
 478     { "a.b..xn---q----jra.e", "B", "a.b..-q--\\u00E4-.e",
 479       UIDNA_ERROR_EMPTY_LABEL|UIDNA_ERROR_LEADING_HYPHEN|UIDNA_ERROR_TRAILING_HYPHEN|
 480       UIDNA_ERROR_HYPHEN_3_4 },
 481     { "a..c", "B", "a..c", UIDNA_ERROR_EMPTY_LABEL },
 482     { "a.-b.", "B", "a.-b.", UIDNA_ERROR_LEADING_HYPHEN },
 483     { "a.b-.c", "B", "a.b-.c", UIDNA_ERROR_TRAILING_HYPHEN },
 484     { "a.-.c", "B", "a.-.c", UIDNA_ERROR_LEADING_HYPHEN|UIDNA_ERROR_TRAILING_HYPHEN },
 485     { "a.bc--de.f", "B", "a.bc--de.f", UIDNA_ERROR_HYPHEN_3_4 },
 486     { "\\u00E4.\\u00AD.c", "B", "\\u00E4..c", UIDNA_ERROR_EMPTY_LABEL },
 487     { "\\u00E4.-b.", "B", "\\u00E4.-b.", UIDNA_ERROR_LEADING_HYPHEN },
 488     { "\\u00E4.b-.c", "B", "\\u00E4.b-.c", UIDNA_ERROR_TRAILING_HYPHEN },
 489     { "\\u00E4.-.c", "B", "\\u00E4.-.c", UIDNA_ERROR_LEADING_HYPHEN|UIDNA_ERROR_TRAILING_HYPHEN },
 490     { "\\u00E4.bc--de.f", "B", "\\u00E4.bc--de.f", UIDNA_ERROR_HYPHEN_3_4 },
 491     { "a.b.\\u0308c.d", "B", "a.b.\\uFFFDc.d", UIDNA_ERROR_LEADING_COMBINING_MARK },
 492     { "a.b.xn--c-bcb.d", "B",
 493       "a.b.xn--c-bcb\\uFFFD.d", UIDNA_ERROR_LEADING_COMBINING_MARK|UIDNA_ERROR_INVALID_ACE_LABEL },
 494     // BiDi
 495     { "A0", "B", "a0", 0 },
 496     { "0A", "B", "0a", 0 },  // all-LTR is ok to start with a digit (EN)
 497     { "0A.\\u05D0", "B",  // ASCII label does not start with L/R/AL
 498       "0a.\\u05D0", UIDNA_ERROR_BIDI },
 499     { "c.xn--0-eha.xn--4db", "B",  // 2nd label does not start with L/R/AL
 500       "c.0\\u00FC.\\u05D0", UIDNA_ERROR_BIDI },
 501     { "b-.\\u05D0", "B",  // label does not end with L/EN
 502       "b-.\\u05D0", UIDNA_ERROR_TRAILING_HYPHEN|UIDNA_ERROR_BIDI },
 503     { "d.xn----dha.xn--4db", "B",  // 2nd label does not end with L/EN
 504       "d.\\u00FC-.\\u05D0", UIDNA_ERROR_TRAILING_HYPHEN|UIDNA_ERROR_BIDI },
 505     { "a\\u05D0", "B", "a\\u05D0", UIDNA_ERROR_BIDI },  // first dir != last dir
 506     { "\\u05D0\\u05C7", "B", "\\u05D0\\u05C7", 0 },
 507     { "\\u05D09\\u05C7", "B", "\\u05D09\\u05C7", 0 },
 508     { "\\u05D0a\\u05C7", "B", "\\u05D0a\\u05C7", UIDNA_ERROR_BIDI },  // first dir != last dir
 509     { "\\u05D0\\u05EA", "B", "\\u05D0\\u05EA", 0 },
 510     { "\\u05D0\\u05F3\\u05EA", "B", "\\u05D0\\u05F3\\u05EA", 0 },
 511     { "a\\u05D0Tz", "B", "a\\u05D0tz", UIDNA_ERROR_BIDI },  // mixed dir
 512     { "\\u05D0T\\u05EA", "B", "\\u05D0t\\u05EA", UIDNA_ERROR_BIDI },  // mixed dir
 513     { "\\u05D07\\u05EA", "B", "\\u05D07\\u05EA", 0 },
 514     { "\\u05D0\\u0667\\u05EA", "B", "\\u05D0\\u0667\\u05EA", 0 },  // Arabic 7 in the middle
 515     { "a7\\u0667z", "B", "a7\\u0667z", UIDNA_ERROR_BIDI },  // AN digit in LTR
 516     { "\\u05D07\\u0667\\u05EA", "B",  // mixed EN/AN digits in RTL
 517       "\\u05D07\\u0667\\u05EA", UIDNA_ERROR_BIDI },
 518     // ZWJ
 519     { "\\u0BB9\\u0BCD\\u200D", "N", "\\u0BB9\\u0BCD\\u200D", 0 },  // Virama+ZWJ
 520     { "\\u0BB9\\u200D", "N", "\\u0BB9\\u200D", UIDNA_ERROR_CONTEXTJ },  // no Virama
 521     { "\\u200D", "N", "\\u200D", UIDNA_ERROR_CONTEXTJ },  // no Virama
 522     // ZWNJ
 523     { "\\u0BB9\\u0BCD\\u200C", "N", "\\u0BB9\\u0BCD\\u200C", 0 },  // Virama+ZWNJ
 524     { "\\u0BB9\\u200C", "N", "\\u0BB9\\u200C", UIDNA_ERROR_CONTEXTJ },  // no Virama
 525     { "\\u200C", "N", "\\u200C", UIDNA_ERROR_CONTEXTJ },  // no Virama
 526     { "\\u0644\\u0670\\u200C\\u06ED\\u06EF", "N",  // Joining types D T ZWNJ T R
 527       "\\u0644\\u0670\\u200C\\u06ED\\u06EF", 0 },
 528     { "\\u0644\\u0670\\u200C\\u06EF", "N",  // D T ZWNJ R
 529       "\\u0644\\u0670\\u200C\\u06EF", 0 },
 530     { "\\u0644\\u200C\\u06ED\\u06EF", "N",  // D ZWNJ T R
 531       "\\u0644\\u200C\\u06ED\\u06EF", 0 },
 532     { "\\u0644\\u200C\\u06EF", "N",  // D ZWNJ R
 533       "\\u0644\\u200C\\u06EF", 0 },
 534     { "\\u0644\\u0670\\u200C\\u06ED", "N",  // D T ZWNJ T
 535       "\\u0644\\u0670\\u200C\\u06ED", UIDNA_ERROR_BIDI|UIDNA_ERROR_CONTEXTJ },
 536     { "\\u06EF\\u200C\\u06EF", "N",  // R ZWNJ R
 537       "\\u06EF\\u200C\\u06EF", UIDNA_ERROR_CONTEXTJ },
 538     { "\\u0644\\u200C", "N",  // D ZWNJ
 539       "\\u0644\\u200C", UIDNA_ERROR_BIDI|UIDNA_ERROR_CONTEXTJ },
 540     { "\\u0660\\u0661", "B",  // Arabic-Indic Digits alone
 541       "\\u0660\\u0661", UIDNA_ERROR_BIDI },
 542     { "\\u06F0\\u06F1", "B",  // Extended Arabic-Indic Digits alone
 543       "\\u06F0\\u06F1", 0 },
 544     { "\\u0660\\u06F1", "B",  // Mixed Arabic-Indic Digits
 545       "\\u0660\\u06F1", UIDNA_ERROR_CONTEXTO_DIGITS|UIDNA_ERROR_BIDI },
 546     // All of the CONTEXTO "Would otherwise have been DISALLOWED" characters
 547     // in their correct contexts,
 548     // then each in incorrect context.
 549     { "l\\u00B7l\\u4E00\\u0375\\u03B1\\u05D0\\u05F3\\u05F4\\u30FB", "B",
 550       "l\\u00B7l\\u4E00\\u0375\\u03B1\\u05D0\\u05F3\\u05F4\\u30FB", UIDNA_ERROR_BIDI },
 551     { "l\\u00B7", "B",
 552       "l\\u00B7", UIDNA_ERROR_CONTEXTO_PUNCTUATION },
 553     { "\\u00B7l", "B",
 554       "\\u00B7l", UIDNA_ERROR_CONTEXTO_PUNCTUATION },
 555     { "\\u0375", "B",
 556       "\\u0375", UIDNA_ERROR_CONTEXTO_PUNCTUATION },
 557     { "\\u03B1\\u05F3", "B",
 558       "\\u03B1\\u05F3", UIDNA_ERROR_CONTEXTO_PUNCTUATION|UIDNA_ERROR_BIDI },
 559     { "\\u05F4", "B",
 560       "\\u05F4", UIDNA_ERROR_CONTEXTO_PUNCTUATION },
 561     { "l\\u30FB", "B",
 562       "l\\u30FB", UIDNA_ERROR_CONTEXTO_PUNCTUATION },
 563     // Ticket #8137: UTS #46 toUnicode() fails with non-ASCII labels that turn
 564     // into 15 characters (UChars).
 565     // The bug was in u_strFromPunycode() which did not write the last character
 566     // if it just so fit into the end of the destination buffer.
 567     // The UTS #46 code gives a default-capacity UnicodeString as the destination buffer,
 568     // and the internal UnicodeString capacity is currently 15 UChars on 64-bit machines
 569     // but 13 on 32-bit machines.
 570     // Label with 15 UChars, for 64-bit-machine testing:
 571     { "aaaaaaaaaaaaa\\u00FCa.de", "B", "aaaaaaaaaaaaa\\u00FCa.de", 0 },
 572     { "xn--aaaaaaaaaaaaaa-ssb.de", "B", "aaaaaaaaaaaaa\\u00FCa.de", 0 },
 573     { "abschlu\\u00DFpr\\u00FCfung.de", "N", "abschlu\\u00DFpr\\u00FCfung.de", 0 },
 574     { "xn--abschluprfung-hdb15b.de", "B", "abschlu\\u00DFpr\\u00FCfung.de", 0 },
 575     // Label with 13 UChars, for 32-bit-machine testing:
 576     { "xn--aaaaaaaaaaaa-nlb.de", "B", "aaaaaaaaaaa\\u00FCa.de", 0 },
 577     { "xn--schluprfung-z6a39a.de", "B", "schlu\\u00DFpr\\u00FCfung.de", 0 },
 578     // { "", "B",
 579     //   "", 0 },
 580 };
 581
 582 void UTS46Test::TestSomeCases() {
 583     IcuTestErrorCode errorCode(*this, "TestSomeCases");
 584     char buffer[400], buffer2[400];
 585     int32_t i;
 586     for(i=0; i<LENGTHOF(testCases); ++i) {
 587         const TestCase &testCase=testCases[i];
 588         UnicodeString input(ctou(testCase.s));
 589         UnicodeString expected(ctou(testCase.u));
 590         // ToASCII/ToUnicode, transitional/nontransitional
 591         UnicodeString aT, uT, aN, uN;
 592         IDNAInfo aTInfo, uTInfo, aNInfo, uNInfo;
 593         trans->nameToASCII(input, aT, aTInfo, errorCode);
 594         trans->nameToUnicode(input, uT, uTInfo, errorCode);
 595         nontrans->nameToASCII(input, aN, aNInfo, errorCode);
 596         nontrans->nameToUnicode(input, uN, uNInfo, errorCode);
 597         if(errorCode.logIfFailureAndReset("first-level processing [%d/%s] %s",
 598                                           (int)i, testCase.o, testCase.s)
 599         ) {
 600             continue;
 601         }
 602         // ToUnicode does not set length errors.
 603         uint32_t uniErrors=testCase.errors&~
 604             (UIDNA_ERROR_EMPTY_LABEL|
 605              UIDNA_ERROR_LABEL_TOO_LONG|
 606              UIDNA_ERROR_DOMAIN_NAME_TOO_LONG);
 607         char mode=testCase.o[0];
 608         if(mode=='B' || mode=='N') {
 609             if(uNInfo.getErrors()!=uniErrors) {
 610                 errln("N.nameToUnicode([%d] %s) unexpected errors %04lx",
 611                       (int)i, testCase.s, (long)uNInfo.getErrors());
 612                 continue;
 613             }
 614             if(uN!=expected) {
 615                 prettify(uN).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 616                 errln("N.nameToUnicode([%d] %s) unexpected string %s",
 617                       (int)i, testCase.s, buffer);
 618                 continue;
 619             }
 620             if(aNInfo.getErrors()!=testCase.errors) {
 621                 errln("N.nameToASCII([%d] %s) unexpected errors %04lx",
 622                       (int)i, testCase.s, (long)aNInfo.getErrors());
 623                 continue;
 624             }
 625         }
 626         if(mode=='B' || mode=='T') {
 627             if(uTInfo.getErrors()!=uniErrors) {
 628                 errln("T.nameToUnicode([%d] %s) unexpected errors %04lx",
 629                       (int)i, testCase.s, (long)uTInfo.getErrors());
 630                 continue;
 631             }
 632             if(uT!=expected) {
 633                 prettify(uT).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 634                 errln("T.nameToUnicode([%d] %s) unexpected string %s",
 635                       (int)i, testCase.s, buffer);
 636                 continue;
 637             }
 638             if(aTInfo.getErrors()!=testCase.errors) {
 639                 errln("T.nameToASCII([%d] %s) unexpected errors %04lx",
 640                       (int)i, testCase.s, (long)aTInfo.getErrors());
 641                 continue;
 642             }
 643         }
 644         // ToASCII is all-ASCII if no severe errors
 645         if((aNInfo.getErrors()&severeErrors)==0 && !isASCII(aN)) {
 646             prettify(aN).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 647             errln("N.nameToASCII([%d] %s) (errors %04lx) result is not ASCII %s",
 648                   (int)i, testCase.s, aNInfo.getErrors(), buffer);
 649             continue;
 650         }
 651         if((aTInfo.getErrors()&severeErrors)==0 && !isASCII(aT)) {
 652             prettify(aT).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 653             errln("T.nameToASCII([%d] %s) (errors %04lx) result is not ASCII %s",
 654                   (int)i, testCase.s, aTInfo.getErrors(), buffer);
 655             continue;
 656         }
 657         if(verbose) {
 658             char m= mode=='B' ? mode : 'N';
 659             prettify(aN).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 660             logln("%c.nameToASCII([%d] %s) (errors %04lx) result string: %s",
 661                   m, (int)i, testCase.s, aNInfo.getErrors(), buffer);
 662             if(mode!='B') {
 663                 prettify(aT).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 664                 logln("T.nameToASCII([%d] %s) (errors %04lx) result string: %s",
 665                       (int)i, testCase.s, aTInfo.getErrors(), buffer);
 666             }
 667         }
 668         // second-level processing
 669         UnicodeString aTuN, uTaN, aNuN, uNaN;
 670         IDNAInfo aTuNInfo, uTaNInfo, aNuNInfo, uNaNInfo;
 671         nontrans->nameToUnicode(aT, aTuN, aTuNInfo, errorCode);
 672         nontrans->nameToASCII(uT, uTaN, uTaNInfo, errorCode);
 673         nontrans->nameToUnicode(aN, aNuN, aNuNInfo, errorCode);
 674         nontrans->nameToASCII(uN, uNaN, uNaNInfo, errorCode);
 675         if(errorCode.logIfFailureAndReset("second-level processing [%d/%s] %s",
 676                                           (int)i, testCase.o, testCase.s)
 677         ) {
 678             continue;
 679         }
 680         if(aN!=uNaN) {
 681             prettify(aN).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 682             prettify(uNaN).extract(0, 0x7fffffff, buffer2, LENGTHOF(buffer2));
 683             errln("N.nameToASCII([%d] %s)!=N.nameToUnicode().N.nameToASCII() "
 684                   "(errors %04lx) %s vs. %s",
 685                   (int)i, testCase.s, aNInfo.getErrors(), buffer, buffer2);
 686             continue;
 687         }
 688         if(aT!=uTaN) {
 689             prettify(aT).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 690             prettify(uTaN).extract(0, 0x7fffffff, buffer2, LENGTHOF(buffer2));
 691             errln("T.nameToASCII([%d] %s)!=T.nameToUnicode().N.nameToASCII() "
 692                   "(errors %04lx) %s vs. %s",
 693                   (int)i, testCase.s, aNInfo.getErrors(), buffer, buffer2);
 694             continue;
 695         }
 696         if(uN!=aNuN) {
 697             prettify(uN).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 698             prettify(aNuN).extract(0, 0x7fffffff, buffer2, LENGTHOF(buffer2));
 699             errln("N.nameToUnicode([%d] %s)!=N.nameToASCII().N.nameToUnicode() "
 700                   "(errors %04lx) %s vs. %s",
 701                   (int)i, testCase.s, uNInfo.getErrors(), buffer, buffer2);
 702             continue;
 703         }
 704         if(uT!=aTuN) {
 705             prettify(uT).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 706             prettify(aTuN).extract(0, 0x7fffffff, buffer2, LENGTHOF(buffer2));
 707             errln("T.nameToUnicode([%d] %s)!=T.nameToASCII().N.nameToUnicode() "
 708                   "(errors %04lx) %s vs. %s",
 709                   (int)i, testCase.s, uNInfo.getErrors(), buffer, buffer2);
 710             continue;
 711         }
 712         // labelToUnicode
 713         UnicodeString aTL, uTL, aNL, uNL;
 714         IDNAInfo aTLInfo, uTLInfo, aNLInfo, uNLInfo;
 715         trans->labelToASCII(input, aTL, aTLInfo, errorCode);
 716         trans->labelToUnicode(input, uTL, uTLInfo, errorCode);
 717         nontrans->labelToASCII(input, aNL, aNLInfo, errorCode);
 718         nontrans->labelToUnicode(input, uNL, uNLInfo, errorCode);
 719         if(errorCode.logIfFailureAndReset("labelToXYZ processing [%d/%s] %s",
 720                                           (int)i, testCase.o, testCase.s)
 721         ) {
 722             continue;
 723         }
 724         if(aN.indexOf((UChar)0x2e)<0) {
 725             if(aN!=aNL || aNInfo.getErrors()!=aNLInfo.getErrors()) {
 726                 prettify(aN).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 727                 prettify(aNL).extract(0, 0x7fffffff, buffer2, LENGTHOF(buffer2));
 728                 errln("N.nameToASCII([%d] %s)!=N.labelToASCII() "
 729                       "(errors %04lx vs %04lx) %s vs. %s",
 730                       (int)i, testCase.s, aNInfo.getErrors(), aNLInfo.getErrors(), buffer, buffer2);
 731                 continue;
 732             }
 733         } else {
 734             if((aNLInfo.getErrors()&UIDNA_ERROR_LABEL_HAS_DOT)==0) {
 735                 errln("N.labelToASCII([%d] %s) errors %04lx missing UIDNA_ERROR_LABEL_HAS_DOT",
 736                       (int)i, testCase.s, (long)aNLInfo.getErrors());
 737                 continue;
 738             }
 739         }
 740         if(aT.indexOf((UChar)0x2e)<0) {
 741             if(aT!=aTL || aTInfo.getErrors()!=aTLInfo.getErrors()) {
 742                 prettify(aT).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 743                 prettify(aTL).extract(0, 0x7fffffff, buffer2, LENGTHOF(buffer2));
 744                 errln("T.nameToASCII([%d] %s)!=T.labelToASCII() "
 745                       "(errors %04lx vs %04lx) %s vs. %s",
 746                       (int)i, testCase.s, aTInfo.getErrors(), aTLInfo.getErrors(), buffer, buffer2);
 747                 continue;
 748             }
 749         } else {
 750             if((aTLInfo.getErrors()&UIDNA_ERROR_LABEL_HAS_DOT)==0) {
 751                 errln("T.labelToASCII([%d] %s) errors %04lx missing UIDNA_ERROR_LABEL_HAS_DOT",
 752                       (int)i, testCase.s, (long)aTLInfo.getErrors());
 753                 continue;
 754             }
 755         }
 756         if(uN.indexOf((UChar)0x2e)<0) {
 757             if(uN!=uNL || uNInfo.getErrors()!=uNLInfo.getErrors()) {
 758                 prettify(uN).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 759                 prettify(uNL).extract(0, 0x7fffffff, buffer2, LENGTHOF(buffer2));
 760                 errln("N.nameToUnicode([%d] %s)!=N.labelToUnicode() "
 761                       "(errors %04lx vs %04lx) %s vs. %s",
 762                       (int)i, testCase.s, uNInfo.getErrors(), uNLInfo.getErrors(), buffer, buffer2);
 763                 continue;
 764             }
 765         } else {
 766             if((uNLInfo.getErrors()&UIDNA_ERROR_LABEL_HAS_DOT)==0) {
 767                 errln("N.labelToUnicode([%d] %s) errors %04lx missing UIDNA_ERROR_LABEL_HAS_DOT",
 768                       (int)i, testCase.s, (long)uNLInfo.getErrors());
 769                 continue;
 770             }
 771         }
 772         if(uT.indexOf((UChar)0x2e)<0) {
 773             if(uT!=uTL || uTInfo.getErrors()!=uTLInfo.getErrors()) {
 774                 prettify(uT).extract(0, 0x7fffffff, buffer, LENGTHOF(buffer));
 775                 prettify(uTL).extract(0, 0x7fffffff, buffer2, LENGTHOF(buffer2));
 776                 errln("T.nameToUnicode([%d] %s)!=T.labelToUnicode() "
 777                       "(errors %04lx vs %04lx) %s vs. %s",
 778                       (int)i, testCase.s, uTInfo.getErrors(), uTLInfo.getErrors(), buffer, buffer2);
 779                 continue;
 780             }
 781         } else {
 782             if((uTLInfo.getErrors()&UIDNA_ERROR_LABEL_HAS_DOT)==0) {
 783                 errln("T.labelToUnicode([%d] %s) errors %04lx missing UIDNA_ERROR_LABEL_HAS_DOT",
 784                       (int)i, testCase.s, (long)uTLInfo.getErrors());
 785                 continue;
 786             }
 787         }
 788         // Differences between transitional and nontransitional processing
 789         if(mode=='B') {
 790             if( aNInfo.isTransitionalDifferent() ||
 791                 aTInfo.isTransitionalDifferent() ||
 792                 uNInfo.isTransitionalDifferent() ||
 793                 uTInfo.isTransitionalDifferent() ||
 794                 aNLInfo.isTransitionalDifferent() ||
 795                 aTLInfo.isTransitionalDifferent() ||
 796                 uNLInfo.isTransitionalDifferent() ||
 797                 uTLInfo.isTransitionalDifferent()
 798             ) {
 799                 errln("B.process([%d] %s) isTransitionalDifferent()", (int)i, testCase.s);
 800                 continue;
 801             }
 802             if( aN!=aT || uN!=uT || aNL!=aTL || uNL!=uTL ||
 803                 aNInfo.getErrors()!=aTInfo.getErrors() || uNInfo.getErrors()!=uTInfo.getErrors() ||
 804                 aNLInfo.getErrors()!=aTLInfo.getErrors() || uNLInfo.getErrors()!=uTLInfo.getErrors()
 805             ) {
 806                 errln("N.process([%d] %s) vs. T.process() different errors or result strings",
 807                       (int)i, testCase.s);
 808                 continue;
 809             }
 810         } else {
 811             if( !aNInfo.isTransitionalDifferent() ||
 812                 !aTInfo.isTransitionalDifferent() ||
 813                 !uNInfo.isTransitionalDifferent() ||
 814                 !uTInfo.isTransitionalDifferent() ||
 815                 !aNLInfo.isTransitionalDifferent() ||
 816                 !aTLInfo.isTransitionalDifferent() ||
 817                 !uNLInfo.isTransitionalDifferent() ||
 818                 !uTLInfo.isTransitionalDifferent()
 819             ) {
 820                 errln("%s.process([%d] %s) !isTransitionalDifferent()",
 821                       testCase.o, (int)i, testCase.s);
 822                 continue;
 823             }
 824             if(aN==aT || uN==uT || aNL==aTL || uNL==uTL) {
 825                 errln("N.process([%d] %s) vs. T.process() same result strings",
 826                       (int)i, testCase.s);
 827                 continue;
 828             }
 829         }
 830         // UTF-8 if we have std::string
 831 #if U_HAVE_STD_STRING
 832         std::string input8, aT8, uT8, aN8, uN8;
 833         StringByteSink<std::string> aT8Sink(&aT8), uT8Sink(&uT8), aN8Sink(&aN8), uN8Sink(&uN8);
 834         IDNAInfo aT8Info, uT8Info, aN8Info, uN8Info;
 835         input.toUTF8String(input8);
 836         trans->nameToASCII_UTF8(input8, aT8Sink, aT8Info, errorCode);
 837         trans->nameToUnicodeUTF8(input8, uT8Sink, uT8Info, errorCode);
 838         nontrans->nameToASCII_UTF8(input8, aN8Sink, aN8Info, errorCode);
 839         nontrans->nameToUnicodeUTF8(input8, uN8Sink, uN8Info, errorCode);
 840         if(errorCode.logIfFailureAndReset("UTF-8 processing [%d/%s] %s",
 841                                           (int)i, testCase.o, testCase.s)
 842         ) {
 843             continue;
 844         }
 845         UnicodeString aT16(UnicodeString::fromUTF8(aT8));
 846         UnicodeString uT16(UnicodeString::fromUTF8(uT8));
 847         UnicodeString aN16(UnicodeString::fromUTF8(aN8));
 848         UnicodeString uN16(UnicodeString::fromUTF8(uN8));
 849         if( aN8Info.getErrors()!=aNInfo.getErrors() ||
 850             uN8Info.getErrors()!=uNInfo.getErrors()
 851         ) {
 852             errln("N.xyzUTF8([%d] %s) vs. UTF-16 processing different errors %04lx vs. %04lx",
 853                   (int)i, testCase.s,
 854                   (long)aN8Info.getErrors(), (long)aNInfo.getErrors());
 855             continue;
 856         }
 857         if( aT8Info.getErrors()!=aTInfo.getErrors() ||
 858             uT8Info.getErrors()!=uTInfo.getErrors()
 859         ) {
 860             errln("T.xyzUTF8([%d] %s) vs. UTF-16 processing different errors %04lx vs. %04lx",
 861                   (int)i, testCase.s,
 862                   (long)aT8Info.getErrors(), (long)aTInfo.getErrors());
 863             continue;
 864         }
 865         if(aT16!=aT || uT16!=uT || aN16!=aN || uN16!=uN) {
 866             errln("%s.xyzUTF8([%d] %s) vs. UTF-16 processing different string results",
 867                   testCase.o, (int)i, testCase.s, (long)aTInfo.getErrors());
 868             continue;
 869         }
 870         if( aT8Info.isTransitionalDifferent()!=aTInfo.isTransitionalDifferent() ||
 871             uT8Info.isTransitionalDifferent()!=uTInfo.isTransitionalDifferent() ||
 872             aN8Info.isTransitionalDifferent()!=aNInfo.isTransitionalDifferent() ||
 873             uN8Info.isTransitionalDifferent()!=uNInfo.isTransitionalDifferent()
 874         ) {
 875             errln("%s.xyzUTF8([%d] %s) vs. UTF-16 processing different isTransitionalDifferent()",
 876                   testCase.o, (int)i, testCase.s);
 877             continue;
 878         }
 879 #endif
 880     }
 881 }
 882
 883 #endif  // UCONFIG_NO_IDNA