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