icuSources/test/cintltst/utransts.c

   1 /*
   2  *******************************************************************************
   3  *   Copyright (C) 1997-2009, International Business Machines
   4  *   Corporation and others.  All Rights Reserved.
   5  *******************************************************************************
   6  *   Date        Name        Description
   7  *   06/23/00    aliu        Creation.
   8  *******************************************************************************
   9  */
  10
  11 #include "unicode/utypes.h"
  12
  13 #if !UCONFIG_NO_TRANSLITERATION
  14
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include "unicode/utrans.h"
  18 #include "unicode/ustring.h"
  19 #include "cintltst.h"
  20
  21 #define TEST(x) addTest(root, &x, "utrans/" # x)
  22
  23 static void TestAPI(void);
  24 static void TestSimpleRules(void);
  25 static void TestFilter(void);
  26 static void TestOpenInverse(void);
  27 static void TestClone(void);
  28 static void TestRegisterUnregister(void);
  29 static void TestExtractBetween(void);
  30 static void TestUnicodeIDs(void);
  31
  32 static void _expectRules(const char*, const char*, const char*);
  33 static void _expect(const UTransliterator* trans, const char* cfrom, const char* cto);
  34
  35 void addUTransTest(TestNode** root);
  36
  37
  38 void
  39 addUTransTest(TestNode** root) {
  40     TEST(TestAPI);
  41     TEST(TestSimpleRules);
  42     TEST(TestFilter);
  43     TEST(TestOpenInverse);
  44     TEST(TestClone);
  45     TEST(TestRegisterUnregister);
  46     TEST(TestExtractBetween);
  47     TEST(TestUnicodeIDs);
  48 }
  49
  50 /*------------------------------------------------------------------
  51  * Replaceable glue
  52  *
  53  * To test the Replaceable glue we have to dummy up a C-based
  54  * Replaceable callback.  This code is for testing purposes only.
  55  *------------------------------------------------------------------*/
  56
  57 typedef struct XReplaceable {
  58     UChar* text;    /* MUST BE null-terminated */
  59 } XReplaceable;
  60
  61 static void InitXReplaceable(XReplaceable* rep, const char* cstring) {
  62     rep->text = malloc(sizeof(UChar) * (strlen(cstring)+1));
  63     u_uastrcpy(rep->text, cstring);
  64 }
  65
  66 static void FreeXReplaceable(XReplaceable* rep) {
  67     if (rep->text != NULL) {
  68         free(rep->text);
  69         rep->text = NULL;
  70     }
  71 }
  72
  73 /* UReplaceableCallbacks callback */
  74 static int32_t Xlength(const UReplaceable* rep) {
  75     const XReplaceable* x = (const XReplaceable*)rep;
  76     return u_strlen(x->text);
  77 }
  78
  79 /* UReplaceableCallbacks callback */
  80 static UChar XcharAt(const UReplaceable* rep, int32_t offset) {
  81     const XReplaceable* x = (const XReplaceable*)rep;
  82     return x->text[offset];
  83 }
  84
  85 /* UReplaceableCallbacks callback */
  86 static UChar32 Xchar32At(const UReplaceable* rep, int32_t offset) {
  87     const XReplaceable* x = (const XReplaceable*)rep;
  88     return x->text[offset];
  89 }
  90
  91 /* UReplaceableCallbacks callback */
  92 static void Xreplace(UReplaceable* rep, int32_t start, int32_t limit,
  93               const UChar* text, int32_t textLength) {
  94     XReplaceable* x = (XReplaceable*)rep;
  95     int32_t newLen = Xlength(rep) + limit - start + textLength;
  96     UChar* newText = (UChar*) malloc(sizeof(UChar) * (newLen+1));
  97     u_strncpy(newText, x->text, start);
  98     u_strncpy(newText + start, text, textLength);
  99     u_strcpy(newText + start + textLength, x->text + limit);
 100     free(x->text);
 101     x->text = newText;
 102 }
 103
 104 /* UReplaceableCallbacks callback */
 105 static void Xcopy(UReplaceable* rep, int32_t start, int32_t limit, int32_t dest) {
 106     XReplaceable* x = (XReplaceable*)rep;
 107     int32_t newLen = Xlength(rep) + limit - start;
 108     UChar* newText = (UChar*) malloc(sizeof(UChar) * (newLen+1));
 109     u_strncpy(newText, x->text, dest);
 110     u_strncpy(newText + dest, x->text + start, limit - start);
 111     u_strcpy(newText + dest + limit - start, x->text + dest);
 112     free(x->text);
 113     x->text = newText;
 114 }
 115
 116 /* UReplaceableCallbacks callback */
 117 static void Xextract(UReplaceable* rep, int32_t start, int32_t limit, UChar* dst) {
 118     XReplaceable* x = (XReplaceable*)rep;
 119     int32_t len = limit - start;
 120     u_strncpy(dst, x->text, len);
 121 }
 122
 123 static void InitXReplaceableCallbacks(UReplaceableCallbacks* callbacks) {
 124     callbacks->length = Xlength;
 125     callbacks->charAt = XcharAt;
 126     callbacks->char32At = Xchar32At;
 127     callbacks->replace = Xreplace;
 128     callbacks->extract = Xextract;
 129     callbacks->copy = Xcopy;
 130 }
 131
 132 /*------------------------------------------------------------------
 133  * Tests
 134  *------------------------------------------------------------------*/
 135
 136 static void TestAPI() {
 137     enum { BUF_CAP = 128 };
 138     char buf[BUF_CAP], buf2[BUF_CAP];
 139     UErrorCode status = U_ZERO_ERROR;
 140     UTransliterator* trans = NULL;
 141     int32_t i, n;
 142
 143     /* Test getAvailableIDs */
 144     n = utrans_countAvailableIDs();
 145     if (n < 1) {
 146         log_err("FAIL: utrans_countAvailableIDs() returned %d\n", n);
 147     } else {
 148         log_verbose("System ID count: %d\n", n);
 149     }
 150     for (i=0; i<n; ++i) {
 151         utrans_getAvailableID(i, buf, BUF_CAP);
 152         if (*buf == 0) {
 153             log_err("FAIL: System transliterator %d: \"\"\n", i);
 154         } else {
 155             log_verbose("System transliterator %d: \"%s\"\n", i, buf);
 156         }
 157     }
 158
 159     /* Test open */
 160     utrans_getAvailableID(0, buf, BUF_CAP);
 161     trans = utrans_open(buf, UTRANS_FORWARD,NULL,0,NULL, &status);
 162     if (U_FAILURE(status)) {
 163         log_err("FAIL: utrans_open(%s) failed, error=%s\n",
 164                 buf, u_errorName(status));
 165     }
 166
 167     else {
 168         /* Test getID */
 169         utrans_getID(trans, buf2, BUF_CAP);
 170         if (0 != strcmp(buf, buf2)) {
 171             log_err("FAIL: utrans_getID(%s) returned %s\n",
 172                     buf, buf2);
 173         }
 174         utrans_close(trans);
 175     }
 176 }
 177
 178 static void TestUnicodeIDs() {
 179     UEnumeration *uenum;
 180     UTransliterator *utrans;
 181     const UChar *id, *id2;
 182     int32_t idLength, id2Length, count, count2;
 183
 184     UErrorCode errorCode;
 185
 186     errorCode=U_ZERO_ERROR;
 187     uenum=utrans_openIDs(&errorCode);
 188     if(U_FAILURE(errorCode)) {
 189         log_err("utrans_openIDs() failed - %s\n", u_errorName(errorCode));
 190         return;
 191     }
 192
 193     count=uenum_count(uenum, &errorCode);
 194     if(U_FAILURE(errorCode) || count<1) {
 195         log_err("uenum_count(transliterator IDs)=%d - %s\n", count, u_errorName(errorCode));
 196     }
 197
 198     count=0;
 199     for(;;) {
 200         id=uenum_unext(uenum, &idLength, &errorCode);
 201         if(U_FAILURE(errorCode)) {
 202             log_err("uenum_unext(transliterator ID %d) failed - %s\n", count, u_errorName(errorCode));
 203             break;
 204         }
 205         if(id==NULL) {
 206             break;
 207         }
 208
 209         if(++count>10) {
 210             /* try to actually open only a few transliterators */
 211             continue;
 212         }
 213
 214         utrans=utrans_openU(id, idLength, UTRANS_FORWARD, NULL, 0, NULL, &errorCode);
 215         if(U_FAILURE(errorCode)) {
 216             log_err("utrans_openU(%s) failed - %s\n", aescstrdup(id, idLength), u_errorName(errorCode));
 217             continue;
 218         }
 219
 220         id2=utrans_getUnicodeID(utrans, &id2Length);
 221         if(idLength!=id2Length || 0!=u_memcmp(id, id2, idLength)) {
 222             log_err("utrans_getUnicodeID(%s) does not match the original ID\n", aescstrdup(id, idLength));
 223         }
 224
 225         utrans_close(utrans);
 226     }
 227
 228     uenum_reset(uenum, &errorCode);
 229     if(U_FAILURE(errorCode) || count<1) {
 230         log_err("uenum_reset(transliterator IDs) failed - %s\n", u_errorName(errorCode));
 231     } else {
 232         count2=uenum_count(uenum, &errorCode);
 233         if(U_FAILURE(errorCode) || count<1) {
 234             log_err("2nd uenum_count(transliterator IDs)=%d - %s\n", count2, u_errorName(errorCode));
 235         } else if(count!=count2) {
 236             log_err("uenum_unext(transliterator IDs) returned %d IDs but uenum_count() after uenum_reset() claims there are %d\n", count, count2);
 237         }
 238     }
 239
 240     uenum_close(uenum);
 241 }
 242
 243 static void TestOpenInverse(){
 244     UErrorCode status=U_ZERO_ERROR;
 245     UTransliterator* t1=NULL;
 246     UTransliterator* inverse1=NULL;
 247     enum { BUF_CAP = 128 };
 248     char buf1[BUF_CAP];
 249     int32_t i=0;
 250
 251     const char TransID[][25]={
 252            "Halfwidth-Fullwidth",
 253            "Fullwidth-Halfwidth",
 254            "Greek-Latin" ,
 255            "Latin-Greek",
 256            /*"Arabic-Latin", // Removed in 2.0*/
 257            /*"Latin-Arabic", // Removed in 2.0*/
 258            "Katakana-Latin",
 259            "Latin-Katakana",
 260            /*"Hebrew-Latin", // Removed in 2.0*/
 261            /*"Latin-Hebrew", // Removed in 2.0*/
 262            "Cyrillic-Latin",
 263            "Latin-Cyrillic",
 264            "Devanagari-Latin",
 265            "Latin-Devanagari",
 266            "Any-Hex",
 267            "Hex-Any"
 268          };
 269
 270     for(i=0; i<sizeof(TransID)/sizeof(TransID[0]); i=i+2){
 271         status = U_ZERO_ERROR;
 272         t1=utrans_open(TransID[i], UTRANS_FORWARD,NULL,0,NULL, &status);
 273         if(t1 == NULL || U_FAILURE(status)){
 274             log_data_err("FAIL: in instantiation for id=%s -> %s (Are you missing data?)\n", TransID[i], u_errorName(status));
 275             continue;
 276         }
 277         inverse1=utrans_openInverse(t1, &status);
 278         if(U_FAILURE(status)){
 279             log_err("FAIL: utrans_openInverse() failed for id=%s. Error=%s\n", TransID[i], myErrorName(status));
 280             continue;
 281         }
 282         utrans_getID(inverse1, buf1, BUF_CAP);
 283         if(strcmp(buf1, TransID[i+1]) != 0){
 284             log_err("FAIL :openInverse() for %s returned %s instead of %s\n", TransID[i], buf1, TransID[i+1]);
 285         }
 286         utrans_close(t1);
 287         utrans_close(inverse1);
 288    }
 289 }
 290
 291 static void TestClone(){
 292     UErrorCode status=U_ZERO_ERROR;
 293     UTransliterator* t1=NULL;
 294     UTransliterator* t2=NULL;
 295     UTransliterator* t3=NULL;
 296     UTransliterator* t4=NULL;
 297     enum { BUF_CAP = 128 };
 298     char buf1[BUF_CAP], buf2[BUF_CAP], buf3[BUF_CAP];
 299
 300     t1=utrans_open("Latin-Devanagari", UTRANS_FORWARD, NULL,0,NULL,&status);
 301     if(U_FAILURE(status)){
 302         log_data_err("FAIL: construction -> %s (Are you missing data?)\n", u_errorName(status));
 303         return;
 304     }
 305     t2=utrans_open("Latin-Greek", UTRANS_FORWARD, NULL,0,NULL,&status);
 306     if(U_FAILURE(status)){
 307         log_err("FAIL: construction\n");
 308         utrans_close(t1);
 309         return;
 310     }
 311
 312     t3=utrans_clone(t1, &status);
 313     t4=utrans_clone(t2, &status);
 314
 315     utrans_getID(t1, buf1, BUF_CAP);
 316     utrans_getID(t2, buf2, BUF_CAP);
 317     utrans_getID(t3, buf3, BUF_CAP);
 318
 319     if(strcmp(buf1, buf3) != 0 ||
 320         strcmp(buf1, buf2) == 0) {
 321         log_err("FAIL: utrans_clone() failed\n");
 322     }
 323
 324     utrans_getID(t4, buf3, BUF_CAP);
 325
 326     if(strcmp(buf2, buf3) != 0 ||
 327         strcmp(buf1, buf3) == 0) {
 328         log_err("FAIL: utrans_clone() failed\n");
 329     }
 330
 331     utrans_close(t1);
 332     utrans_close(t2);
 333     utrans_close(t3);
 334     utrans_close(t4);
 335
 336 }
 337
 338 static void TestRegisterUnregister(){
 339     UErrorCode status=U_ZERO_ERROR;
 340     UTransliterator* t1=NULL;
 341     UTransliterator* rules=NULL, *rules2;
 342     UTransliterator* inverse1=NULL;
 343     UChar rule[]={ 0x0061, 0x003c, 0x003e, 0x0063}; /*a<>b*/
 344
 345     U_STRING_DECL(ID, "TestA-TestB", 11);
 346     U_STRING_INIT(ID, "TestA-TestB", 11);
 347
 348     /* Make sure it doesn't exist */
 349     t1=utrans_open("TestA-TestB", UTRANS_FORWARD,NULL,0,NULL, &status);
 350     if(t1 != NULL || U_SUCCESS(status)) {
 351         log_err("FAIL: TestA-TestB already registered\n");
 352         return;
 353     }
 354     status=U_ZERO_ERROR;
 355     /* Check inverse too */
 356     inverse1=utrans_open("TestA-TestB", UTRANS_REVERSE, NULL,0,NULL,&status);
 357     if(inverse1 != NULL || U_SUCCESS(status)) {
 358         log_err("FAIL: TestA-TestB already registered\n");
 359         return;
 360     }
 361     status=U_ZERO_ERROR;
 362     /* Create it */
 363     rules=utrans_open("TestA-TestB",UTRANS_FORWARD, rule, 4, NULL, &status);
 364     if(U_FAILURE(status)){
 365         log_err("FAIL: utrans_openRules(a<>B) failed with error=%s\n", myErrorName(status));
 366         return;
 367     }
 368
 369     /* clone it so we can register it a second time */
 370     rules2=utrans_clone(rules, &status);
 371     if(U_FAILURE(status)) {
 372         log_err("FAIL: utrans_clone(a<>B) failed with error=%s\n", myErrorName(status));
 373         return;
 374     }
 375
 376     status=U_ZERO_ERROR;
 377     /* Register it */
 378     utrans_register(rules, &status);
 379     if(U_FAILURE(status)){
 380         log_err("FAIL: utrans_register failed with error=%s\n", myErrorName(status));
 381         return;
 382     }
 383     status=U_ZERO_ERROR;
 384     /* Now check again -- should exist now*/
 385     t1= utrans_open("TestA-TestB", UTRANS_FORWARD, NULL,0,NULL,&status);
 386     if(U_FAILURE(status) || t1 == NULL){
 387         log_err("FAIL: TestA-TestB not registered\n");
 388         return;
 389     }
 390     utrans_close(t1);
 391
 392     /*unregister the instance*/
 393     status=U_ZERO_ERROR;
 394     utrans_unregister("TestA-TestB");
 395     /* now Make sure it doesn't exist */
 396     t1=utrans_open("TestA-TestB", UTRANS_FORWARD,NULL,0,NULL, &status);
 397     if(U_SUCCESS(status) || t1 != NULL) {
 398         log_err("FAIL: TestA-TestB isn't unregistered\n");
 399         return;
 400     }
 401     utrans_close(t1);
 402
 403     /* now with utrans_unregisterID(const UChar *) */
 404     status=U_ZERO_ERROR;
 405     utrans_register(rules2, &status);
 406     if(U_FAILURE(status)){
 407         log_err("FAIL: 2nd utrans_register failed with error=%s\n", myErrorName(status));
 408         return;
 409     }
 410     status=U_ZERO_ERROR;
 411     /* Now check again -- should exist now*/
 412     t1= utrans_open("TestA-TestB", UTRANS_FORWARD, NULL,0,NULL,&status);
 413     if(U_FAILURE(status) || t1 == NULL){
 414         log_err("FAIL: 2nd TestA-TestB not registered\n");
 415         return;
 416     }
 417     utrans_close(t1);
 418
 419     /*unregister the instance*/
 420     status=U_ZERO_ERROR;
 421     utrans_unregisterID(ID, -1);
 422     /* now Make sure it doesn't exist */
 423     t1=utrans_openU(ID, -1, UTRANS_FORWARD,NULL,0,NULL, &status);
 424     if(U_SUCCESS(status) || t1 != NULL) {
 425         log_err("FAIL: 2nd TestA-TestB isn't unregistered\n");
 426         return;
 427     }
 428
 429     utrans_close(t1);
 430     utrans_close(inverse1);
 431 }
 432
 433 static void TestSimpleRules() {
 434     /* Test rules */
 435     /* Example: rules 1. ab>x|y
 436      *                2. yc>z
 437      *
 438      * []|eabcd  start - no match, copy e to tranlated buffer
 439      * [e]|abcd  match rule 1 - copy output & adjust cursor
 440      * [ex|y]cd  match rule 2 - copy output & adjust cursor
 441      * [exz]|d   no match, copy d to transliterated buffer
 442      * [exzd]|   done
 443      */
 444     _expectRules("ab>x|y;"
 445                  "yc>z",
 446                  "eabcd", "exzd");
 447
 448     /* Another set of rules:
 449      *    1. ab>x|yzacw
 450      *    2. za>q
 451      *    3. qc>r
 452      *    4. cw>n
 453      *
 454      * []|ab       Rule 1
 455      * [x|yzacw]   No match
 456      * [xy|zacw]   Rule 2
 457      * [xyq|cw]    Rule 4
 458      * [xyqn]|     Done
 459      */
 460     _expectRules("ab>x|yzacw;"
 461                  "za>q;"
 462                  "qc>r;"
 463                  "cw>n",
 464                  "ab", "xyqn");
 465
 466     /* Test categories
 467      */
 468     _expectRules("$dummy=" "\\uE100" ";" /* careful here with E100 */
 469                  "$vowel=[aeiouAEIOU];"
 470                  "$lu=[:Lu:];"
 471                  "$vowel } $lu > '!';"
 472                  "$vowel > '&';"
 473                  "'!' { $lu > '^';"
 474                  "$lu > '*';"
 475                  "a > ERROR",
 476                  "abcdefgABCDEFGU", "&bcd&fg!^**!^*&");
 477
 478     /* Test multiple passes
 479     */
 480     _expectRules("abc > xy;"
 481                  "::Null;"
 482                  "aba > z;",
 483                  "abc ababc aba", "xy abxy z");
 484 }
 485
 486 static void TestFilter() {
 487     UErrorCode status = U_ZERO_ERROR;
 488     UChar filt[128];
 489     UChar buf[128];
 490     UChar exp[128];
 491     char *cbuf;
 492     int32_t limit;
 493     const char* DATA[] = {
 494         "[^c]", /* Filter out 'c' */
 495         "abcde",
 496         "\\u0061\\u0062c\\u0064\\u0065",
 497
 498         "", /* No filter */
 499         "abcde",
 500         "\\u0061\\u0062\\u0063\\u0064\\u0065"
 501     };
 502     int32_t DATA_length = sizeof(DATA) / sizeof(DATA[0]);
 503     int32_t i;
 504
 505     UTransliterator* hex = utrans_open("Any-Hex", UTRANS_FORWARD, NULL,0,NULL,&status);
 506
 507     if (hex == 0 || U_FAILURE(status)) {
 508         log_err("FAIL: utrans_open(Unicode-Hex) failed, error=%s\n",
 509                 u_errorName(status));
 510         goto exit;
 511     }
 512
 513     for (i=0; i<DATA_length; i+=3) {
 514         /*u_uastrcpy(filt, DATA[i]);*/
 515         u_charsToUChars(DATA[i], filt, (int32_t)strlen(DATA[i])+1);
 516         utrans_setFilter(hex, filt, -1, &status);
 517
 518         if (U_FAILURE(status)) {
 519             log_err("FAIL: utrans_setFilter() failed, error=%s\n",
 520                     u_errorName(status));
 521             goto exit;
 522         }
 523
 524         /*u_uastrcpy(buf, DATA[i+1]);*/
 525         u_charsToUChars(DATA[i+1], buf, (int32_t)strlen(DATA[i+1])+1);
 526         limit = 5;
 527         utrans_transUChars(hex, buf, NULL, 128, 0, &limit, &status);
 528
 529         if (U_FAILURE(status)) {
 530             log_err("FAIL: utrans_transUChars() failed, error=%s\n",
 531                     u_errorName(status));
 532             goto exit;
 533         }
 534
 535         cbuf=aescstrdup(buf, -1);
 536         u_charsToUChars(DATA[i+2], exp, (int32_t)strlen(DATA[i+2])+1);
 537         if (0 == u_strcmp(buf, exp)) {
 538             log_verbose("Ok: %s | %s -> %s\n", DATA[i+1], DATA[i], cbuf);
 539         } else {
 540             log_err("FAIL: %s | %s -> %s, expected %s\n", DATA[i+1], DATA[i], cbuf, DATA[i+2]);
 541         }
 542     }
 543
 544  exit:
 545     utrans_close(hex);
 546 }
 547
 548 /**
 549  * Test the UReplaceableCallback extractBetween support.  We use a
 550  * transliterator known to rely on this call.
 551  */
 552 static void TestExtractBetween() {
 553
 554     UTransliterator *trans;
 555     UErrorCode status = U_ZERO_ERROR;
 556     UParseError parseErr;
 557
 558     trans = utrans_open("Lower", UTRANS_FORWARD, NULL, -1,
 559                         &parseErr, &status);
 560
 561     if (U_FAILURE(status)) {
 562         log_err("FAIL: utrans_open(Lower) failed, error=%s\n",
 563                 u_errorName(status));
 564     } else {
 565         _expect(trans, "ABC", "abc");
 566
 567         utrans_close(trans);
 568     }
 569 }
 570
 571 static void _expectRules(const char* crules,
 572                   const char* cfrom,
 573                   const char* cto) {
 574     /* u_uastrcpy has no capacity param for the buffer -- so just
 575      * make all buffers way too big */
 576     enum { CAP = 256 };
 577     UChar rules[CAP];
 578     UTransliterator *trans;
 579     UErrorCode status = U_ZERO_ERROR;
 580     UParseError parseErr;
 581
 582     u_uastrcpy(rules, crules);
 583
 584     trans = utrans_open(crules /*use rules as ID*/, UTRANS_FORWARD, rules, -1,
 585                              &parseErr, &status);
 586     if (U_FAILURE(status)) {
 587         utrans_close(trans);
 588         log_data_err("FAIL: utrans_openRules(%s) failed, error=%s (Are you missing data?)\n",
 589                 crules, u_errorName(status));
 590         return;
 591     }
 592
 593     _expect(trans, cfrom, cto);
 594
 595     utrans_close(trans);
 596 }
 597
 598 static void _expect(const UTransliterator* trans,
 599              const char* cfrom,
 600              const char* cto) {
 601     /* u_uastrcpy has no capacity param for the buffer -- so just
 602      * make all buffers way too big */
 603     enum { CAP = 256 };
 604     UChar from[CAP];
 605     UChar to[CAP];
 606     UChar buf[CAP];
 607     const UChar *ID;
 608     int32_t IDLength;
 609     const char *id;
 610
 611     UErrorCode status = U_ZERO_ERROR;
 612     int32_t limit;
 613     UTransPosition pos;
 614     XReplaceable xrep;
 615     XReplaceable *xrepPtr = &xrep;
 616     UReplaceableCallbacks xrepVtable;
 617
 618     u_uastrcpy(from, cfrom);
 619     u_uastrcpy(to, cto);
 620
 621     ID = utrans_getUnicodeID(trans, &IDLength);
 622     id = aescstrdup(ID, IDLength);
 623
 624     /* utrans_transUChars() */
 625     u_strcpy(buf, from);
 626     limit = u_strlen(buf);
 627     utrans_transUChars(trans, buf, NULL, CAP, 0, &limit, &status);
 628     if (U_FAILURE(status)) {
 629         log_err("FAIL: utrans_transUChars() failed, error=%s\n",
 630                 u_errorName(status));
 631         return;
 632     }
 633
 634     if (0 == u_strcmp(buf, to)) {
 635         log_verbose("Ok: utrans_transUChars(%s) x %s -> %s\n",
 636                     id, cfrom, cto);
 637     } else {
 638         char actual[CAP];
 639         u_austrcpy(actual, buf);
 640         log_err("FAIL: utrans_transUChars(%s) x %s -> %s, expected %s\n",
 641                 id, cfrom, actual, cto);
 642     }
 643
 644     /* utrans_transIncrementalUChars() */
 645     u_strcpy(buf, from);
 646     pos.start = pos.contextStart = 0;
 647     pos.limit = pos.contextLimit = u_strlen(buf);
 648     utrans_transIncrementalUChars(trans, buf, NULL, CAP, &pos, &status);
 649     utrans_transUChars(trans, buf, NULL, CAP, pos.start, &pos.limit, &status);
 650     if (U_FAILURE(status)) {
 651         log_err("FAIL: utrans_transIncrementalUChars() failed, error=%s\n",
 652                 u_errorName(status));
 653         return;
 654     }
 655
 656     if (0 == u_strcmp(buf, to)) {
 657         log_verbose("Ok: utrans_transIncrementalUChars(%s) x %s -> %s\n",
 658                     id, cfrom, cto);
 659     } else {
 660         char actual[CAP];
 661         u_austrcpy(actual, buf);
 662         log_err("FAIL: utrans_transIncrementalUChars(%s) x %s -> %s, expected %s\n",
 663                 id, cfrom, actual, cto);
 664     }
 665
 666     /* utrans_trans() */
 667     InitXReplaceableCallbacks(&xrepVtable);
 668     InitXReplaceable(&xrep, cfrom);
 669     limit = u_strlen(from);
 670     utrans_trans(trans, (UReplaceable*)xrepPtr, &xrepVtable, 0, &limit, &status);
 671     if (U_FAILURE(status)) {
 672         log_err("FAIL: utrans_trans() failed, error=%s\n",
 673                 u_errorName(status));
 674         FreeXReplaceable(&xrep);
 675         return;
 676     }
 677
 678     if (0 == u_strcmp(xrep.text, to)) {
 679         log_verbose("Ok: utrans_trans(%s) x %s -> %s\n",
 680                     id, cfrom, cto);
 681     } else {
 682         char actual[CAP];
 683         u_austrcpy(actual, xrep.text);
 684         log_err("FAIL: utrans_trans(%s) x %s -> %s, expected %s\n",
 685                 id, cfrom, actual, cto);
 686     }
 687     FreeXReplaceable(&xrep);
 688
 689     /* utrans_transIncremental() */
 690     InitXReplaceable(&xrep, cfrom);
 691     pos.start = pos.contextStart = 0;
 692     pos.limit = pos.contextLimit = u_strlen(from);
 693     utrans_transIncremental(trans, (UReplaceable*)xrepPtr, &xrepVtable, &pos, &status);
 694     utrans_trans(trans, (UReplaceable*)xrepPtr, &xrepVtable, pos.start, &pos.limit, &status);
 695     if (U_FAILURE(status)) {
 696         log_err("FAIL: utrans_transIncremental() failed, error=%s\n",
 697                 u_errorName(status));
 698         FreeXReplaceable(&xrep);
 699         return;
 700     }
 701
 702     if (0 == u_strcmp(xrep.text, to)) {
 703         log_verbose("Ok: utrans_transIncremental(%s) x %s -> %s\n",
 704                     id, cfrom, cto);
 705     } else {
 706         char actual[CAP];
 707         u_austrcpy(actual, xrep.text);
 708         log_err("FAIL: utrans_transIncremental(%s) x %s -> %s, expected %s\n",
 709                 id, cfrom, actual, cto);
 710     }
 711     FreeXReplaceable(&xrep);
 712 }
 713
 714 #endif /* #if !UCONFIG_NO_TRANSLITERATION */