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
23static void TestAPI(void);
24static void TestSimpleRules(void);
25static void TestFilter(void);
26static void TestOpenInverse(void);
27static void TestClone(void);
28static void TestRegisterUnregister(void);
29static void TestExtractBetween(void);
30static void TestUnicodeIDs(void);
31
32static void _expectRules(const char*, const char*, const char*);
33static void _expect(const UTransliterator* trans, const char* cfrom, const char* cto);
34
35void addUTransTest(TestNode** root);
36
37
38void
39addUTransTest(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
57typedef struct XReplaceable {
58    UChar* text;    /* MUST BE null-terminated */
59} XReplaceable;
60
61static void InitXReplaceable(XReplaceable* rep, const char* cstring) {
62    rep->text = malloc(sizeof(UChar) * (strlen(cstring)+1));
63    u_uastrcpy(rep->text, cstring);
64}
65
66static void FreeXReplaceable(XReplaceable* rep) {
67    if (rep->text != NULL) {
68        free(rep->text);
69        rep->text = NULL;
70    }
71}
72
73/* UReplaceableCallbacks callback */
74static int32_t Xlength(const UReplaceable* rep) {
75    const XReplaceable* x = (const XReplaceable*)rep;
76    return u_strlen(x->text);
77}
78
79/* UReplaceableCallbacks callback */
80static 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 */
86static 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 */
92static 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 */
105static 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 */
117static 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
123static 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
136static 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
178static 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
243static 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
291static 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
338static 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
433static 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
486static 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 */
552static 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
571static 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
598static 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 */
715