← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/icu/gutsy-updates

« back to all changes in this revision

Viewing changes to source/test/intltest/cpdtrtst.cpp

  • Committer: Package Import Robot
  • Author(s): Jay Berkenbilt
  • Date: 2005-11-19 11:29:31 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20051119112931-vcizkrp10tli4enw
Tags: 3.4-3
Explicitly build with g++ 3.4.  The current ICU fails its test suite
with 4.0 but not with 3.4.  Future versions should work properly with
4.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/test/intltest/cpdtrtst.cpp
1
 
/*
2
 
*****************************************************************************************
3
 
*                                                                                       *
4
 
* COPYRIGHT:                                                                            *
5
 
*   (C) Copyright International Business Machines Corporation,  2001                    *
6
 
*   Licensed Material - Program-Property of IBM - All Rights Reserved.                  *
7
 
*   US Government Users Restricted Rights - Use, duplication, or disclosure             *
8
 
*   restricted by GSA ADP Schedule Contract with IBM Corp.                              *
9
 
*                                                                                       *
10
 
*****************************************************************************************
11
 
************************************************************************
12
 
*   Date        Name        Description
13
 
*   03/09/2000   Madhu        Creation.
14
 
************************************************************************/
15
 
 
16
 
#include "ittrans.h"
17
 
#include "cpdtrtst.h"
18
 
#include "unicode/utypes.h"
19
 
#include "unicode/translit.h"
20
 
#include "unicode/cpdtrans.h"
21
 
#include "intltest.h"
22
 
#include "cmemory.h"
23
 
#include <string.h>
24
 
#include <stdio.h>
25
 
 
26
 
//---------------------------------------------
27
 
// runIndexedTest
28
 
//---------------------------------------------
29
 
 
30
 
void
31
 
CompoundTransliteratorTest::runIndexedTest(int32_t index, UBool exec,
32
 
                                           const char* &name, char* /*par*/) {
33
 
    switch (index) {
34
 
        TESTCASE(0,TestConstruction);
35
 
        TESTCASE(1,TestCloneEqual);
36
 
        TESTCASE(2,TestGetCount);
37
 
        TESTCASE(3,TestGetSetAdoptTransliterator);
38
 
        TESTCASE(4,TestTransliterate);
39
 
        default: name = ""; break;
40
 
    }
41
 
}
42
 
 
43
 
void CompoundTransliteratorTest::TestConstruction(){
44
 
     logln("Testing the construction of the compound Transliterator");
45
 
   UnicodeString names[]={"Greek-Latin", "Latin-Devanagari", "Devanagari-Latin", "Latin-Greek"};
46
 
   UParseError parseError;
47
 
   UErrorCode status=U_ZERO_ERROR;
48
 
   Transliterator* t1=Transliterator::createInstance(names[0], UTRANS_FORWARD, parseError, status);
49
 
   Transliterator* t2=Transliterator::createInstance(names[1], UTRANS_FORWARD, parseError, status);
50
 
   Transliterator* t3=Transliterator::createInstance(names[2], UTRANS_FORWARD, parseError, status);
51
 
   Transliterator* t4=Transliterator::createInstance(names[3], UTRANS_FORWARD, parseError, status);
52
 
   if(U_FAILURE(status)){
53
 
       errln("Transliterator construction failed");
54
 
       return;
55
 
   }
56
 
 
57
 
 
58
 
   Transliterator* transarray1[]={t1};
59
 
   Transliterator* transarray2[]={t1, t4};
60
 
   Transliterator* transarray3[]={t4, t1, t2};
61
 
   Transliterator* transarray4[]={t1, t2, t3, t4};
62
 
 
63
 
   Transliterator** transarray[4]; 
64
 
   transarray[0] = transarray1;
65
 
   transarray[1] = transarray2;
66
 
   transarray[2] = transarray3;
67
 
   transarray[3] = transarray4;
68
 
 
69
 
   const UnicodeString IDs[]={
70
 
       names[0], 
71
 
       names[0]+";"+names[3], 
72
 
       names[3]+";"+names[1]+";"+names[2], 
73
 
       names[0]+";"+names[1]+";"+names[2]+";"+names[3] 
74
 
   };
75
 
 
76
 
   uint16_t i=0;
77
 
   for(i=0; i<4; i++){
78
 
       status = U_ZERO_ERROR;
79
 
       CompoundTransliterator *cpdtrans=new CompoundTransliterator(IDs[i],parseError, status);
80
 
       if (U_FAILURE(status)) {
81
 
           errln("Construction using CompoundTransliterator(UnicodeString&, Direction, UnicodeFilter*)  failed");
82
 
       }
83
 
       delete cpdtrans;
84
 
 
85
 
       CompoundTransliterator *cpdtrans2=new CompoundTransliterator(transarray[i], i+1);
86
 
       if(cpdtrans2 == 0){
87
 
           errln("Construction using CompoundTransliterator(Transliterator* const transliterators[], "
88
 
                           "int32_t count, UnicodeFilter* adoptedFilter = 0)  failed");
89
 
           continue;
90
 
       }
91
 
       CompoundTransliterator *copycpd=new CompoundTransliterator(*cpdtrans2);
92
 
       if(copycpd->getCount() != cpdtrans2->getCount() || copycpd->getID() != cpdtrans2->getID()) {
93
 
           errln("Copy construction failed");
94
 
           continue;
95
 
       }
96
 
 
97
 
 
98
 
       delete copycpd;
99
 
       delete cpdtrans2;
100
 
 
101
 
   }
102
 
   {
103
 
    /*Test Jitterbug 914 */
104
 
    UErrorCode err = U_ZERO_ERROR;
105
 
    CompoundTransliterator  cpdTrans(UnicodeString("Latin-Hangul"),UTRANS_REVERSE,NULL,parseError,err);
106
 
    UnicodeString newID =cpdTrans.getID();
107
 
    if(newID!=UnicodeString("Hangul-Latin")){
108
 
        errln(UnicodeString("Test for Jitterbug 914 for cpdTrans(UnicodeString(\"Latin-Hangul\"),UTRANS_REVERSE,NULL,err) failed"));
109
 
    }
110
 
   }
111
 
   delete t1;
112
 
   delete t2;
113
 
   delete t3;
114
 
   delete t4;
115
 
 
116
 
}
117
 
 
118
 
void CompoundTransliteratorTest::TestCloneEqual(){ 
119
 
    logln("Testing the clone() and equality operator functions of Compound Transliterator");
120
 
    UErrorCode status = U_ZERO_ERROR;
121
 
    UParseError parseError;
122
 
    CompoundTransliterator  *ct1=new CompoundTransliterator("Greek-Latin;Latin-Devanagari",parseError,status);
123
 
    if(U_FAILURE(status)){
124
 
        errln("construction failed");
125
 
        delete ct1;
126
 
        return;
127
 
    }
128
 
    CompoundTransliterator  *ct2=new CompoundTransliterator("Greek-Latin", parseError, status);
129
 
    if(U_FAILURE(status)){
130
 
        errln("construction failed");
131
 
        delete ct1;
132
 
        delete ct2;
133
 
        return;
134
 
    }
135
 
    CompoundTransliterator *copyct1=new CompoundTransliterator(*ct1);
136
 
    if(copyct1 == 0){
137
 
        errln("copy construction failed");
138
 
        return;
139
 
    }
140
 
    CompoundTransliterator *copyct2=new CompoundTransliterator(*ct2);
141
 
    if(copyct2 == 0){
142
 
        errln("copy construction failed");
143
 
        return;
144
 
    }
145
 
    CompoundTransliterator equalct1=*copyct1;
146
 
    CompoundTransliterator equalct2=*copyct2;
147
 
 
148
 
    if(copyct1->getID()     != ct1->getID()    || copyct2->getID()    != ct2->getID()    || 
149
 
        copyct1->getCount() != ct1->getCount() || copyct2->getCount() != ct2->getCount() ||
150
 
        copyct2->getID()    == ct1->getID()    || copyct1->getID()    == ct2->getID()    ||
151
 
        copyct2->getCount() == ct1->getCount() || copyct1->getCount() == ct2->getCount() ){
152
 
        errln("Error: copy constructors failed");
153
 
    }
154
 
 
155
 
    if(equalct1.getID()     != ct1->getID()        || equalct2.getID()    != ct2->getID()     || 
156
 
        equalct1.getID()    != copyct1->getID()    || equalct2.getID()    != copyct2->getID() || 
157
 
        equalct1.getCount() != ct1->getCount()     || equalct2.getCount() != ct2->getCount()  ||
158
 
        copyct2->getID()    == ct1->getID()        || copyct1->getID()    == ct2->getID()     ||
159
 
        equalct1.getCount() != copyct1->getCount() || equalct2.getCount() != copyct2->getCount() ||
160
 
        equalct2.getCount() == ct1->getCount()     || equalct1.getCount() == ct2->getCount() ) {
161
 
        errln("Error: =operator or copy constructor failed");
162
 
    }
163
 
 
164
 
    CompoundTransliterator *clonect1a=(CompoundTransliterator*)ct1->clone();
165
 
    CompoundTransliterator *clonect1b=(CompoundTransliterator*)equalct1.clone();
166
 
    CompoundTransliterator *clonect2a=(CompoundTransliterator*)ct2->clone();
167
 
    CompoundTransliterator *clonect2b=(CompoundTransliterator*)copyct2->clone();
168
 
 
169
 
 
170
 
    if(clonect1a->getID()  != ct1->getID()       || clonect1a->getCount() != ct1->getCount()        ||
171
 
        clonect1a->getID() != clonect1b->getID() || clonect1a->getCount() != clonect1b->getCount()  ||
172
 
        clonect1a->getID() != equalct1.getID()   || clonect1a->getCount() != equalct1.getCount()    ||
173
 
        clonect1a->getID() != copyct1->getID()   || clonect1a->getCount() != copyct1->getCount()    ||
174
 
 
175
 
        clonect2b->getID() != ct2->getID()       || clonect2a->getCount() != ct2->getCount()        ||
176
 
        clonect2a->getID() != clonect2b->getID() || clonect2a->getCount() != clonect2b->getCount()  ||
177
 
        clonect2a->getID() != equalct2.getID()   || clonect2a->getCount() != equalct2.getCount()    ||
178
 
        clonect2b->getID() != copyct2->getID()   || clonect2b->getCount() != copyct2->getCount()  ) {
179
 
        errln("Error: clone() failed");
180
 
    }
181
 
 
182
 
    delete ct1;
183
 
    delete ct2;
184
 
    delete copyct1;
185
 
    delete copyct2;
186
 
    delete clonect1a;
187
 
    delete clonect1b;
188
 
    delete clonect2a;
189
 
    delete clonect2b;
190
 
 
191
 
}
192
 
 
193
 
void CompoundTransliteratorTest::TestGetCount(){
194
 
    logln("Testing the getCount() API of CompoundTransliterator");
195
 
    UErrorCode status = U_ZERO_ERROR;
196
 
    UParseError parseError;
197
 
    CompoundTransliterator *ct1=new CompoundTransliterator("Halfwidth-Fullwidth;Fullwidth-Halfwidth", parseError, status);
198
 
    CompoundTransliterator *ct2=new CompoundTransliterator("Any-Hex;Hex-Any;Cyrillic-Latin;Latin-Cyrillic", parseError, status);
199
 
    CompoundTransliterator *ct3=(CompoundTransliterator*)ct1;
200
 
    CompoundTransliterator *ct4=new CompoundTransliterator("Latin-Devanagari", parseError, status);
201
 
    CompoundTransliterator *ct5=new CompoundTransliterator(*ct4);
202
 
 
203
 
    if (U_FAILURE(status)) {
204
 
        errln("FAILED: CompoundTransliterator constructor failed");
205
 
    } else
206
 
    if(ct1->getCount() == ct2->getCount() || ct1->getCount() != ct3->getCount() || 
207
 
        ct2->getCount() == ct3->getCount() || 
208
 
        ct4->getCount() != ct5->getCount() || ct4->getCount() == ct1->getCount() ||
209
 
        ct4->getCount() == ct2->getCount() || ct4->getCount() == ct3->getCount()  ||
210
 
        ct5->getCount() == ct2->getCount() || ct5->getCount() == ct3->getCount()  ) {
211
 
        errln("Error: getCount() failed");
212
 
    }
213
 
    delete ct1;
214
 
    delete ct2;
215
 
    delete ct4;
216
 
    delete ct5;
217
 
}
218
 
 
219
 
void CompoundTransliteratorTest::TestGetSetAdoptTransliterator(){
220
 
    logln("Testing the getTransliterator() API of CompoundTransliterator");
221
 
    UnicodeString ID("Latin-Greek;Greek-Latin;Latin-Devanagari;Devanagari-Latin;Latin-Cyrillic;Cyrillic-Latin;Any-Hex;Hex-Any");
222
 
    UErrorCode status = U_ZERO_ERROR;
223
 
    UParseError parseError;
224
 
    CompoundTransliterator *ct1=new CompoundTransliterator(ID, parseError, status);
225
 
    if(U_FAILURE(status)){
226
 
        errln("CompoundTransliterator construction failed");
227
 
        return;
228
 
    }
229
 
    int32_t count=ct1->getCount();
230
 
    UnicodeString *array=split(ID, 0x003b, count);
231
 
    int i;
232
 
    for(i=0; i < count; i++){
233
 
        UnicodeString child= ct1->getTransliterator(i).getID();
234
 
        if(child != *(array+i)){
235
 
            errln("Error getTransliterator() failed: Expected->" + *(array+i) + " Got->" + child);
236
 
        }else {
237
 
            logln("OK: getTransliterator() passed: Expected->" + *(array+i) + " Got->" + child);
238
 
        }
239
 
    }
240
 
    delete []array;
241
 
 
242
 
    logln("Testing setTransliterator() API of CompoundTransliterator");
243
 
    UnicodeString ID2("Hex-Any;Any-Hex;Latin-Cyrillic;Cyrillic-Latin;Halfwidth-Fullwidth;Fullwidth-Halfwidth");
244
 
    array=split(ID2, 0x003b, count);
245
 
    Transliterator** transarray=new Transliterator*[count];
246
 
    for(i=0;i<count;i++){
247
 
        transarray[i]=Transliterator::createInstance(*(array+i), UTRANS_FORWARD, parseError, status);
248
 
        if(U_FAILURE(status)){
249
 
            errln("Error could not create Transliterator with ID :"+*(array+i));
250
 
        }else{
251
 
            logln("The ID for the transltierator created is " + transarray[i]->getID());
252
 
        }
253
 
        status = U_ZERO_ERROR;
254
 
    }
255
 
 
256
 
    /*setTransliterator and adoptTransliterator */
257
 
 
258
 
    ct1->setTransliterators(transarray, count);
259
 
    if(ct1->getCount() != count || ct1->getID() != ID2){
260
 
        errln((UnicodeString)"Error: setTransliterators() failed.\n\t Count:- expected->" + count + (UnicodeString)".  got->" + ct1->getCount() +
261
 
                                                   (UnicodeString)"\n\tID   :- expected->" + ID2 + (UnicodeString)".  got->" + ct1->getID());
262
 
    }
263
 
    else{
264
 
        logln("OK: setTransliterators() passed"); 
265
 
    }
266
 
    /*UnicodeString temp;
267
 
    for(i=0;i<count-1;i++){
268
 
        temp.append(ct1->getTransliterator(i).getID());
269
 
        temp.append(";");
270
 
    }
271
 
    temp.append(ct1->getTransliterator(i).getID());
272
 
    if(temp != ID2){
273
 
        errln("Error: setTransliterator() failed.  Expected->" + ID2 + "\nGot->" + temp);
274
 
    }
275
 
    else{
276
 
        logln("OK: setTransliterator() passed");
277
 
    }*/
278
 
    logln("Testing adoptTransliterator() API of CompoundTransliterator");
279
 
    UnicodeString ID3("Latin-Katakana");
280
 
    Transliterator **transarray2=new Transliterator*[1];
281
 
    transarray2[0] = Transliterator::createInstance(ID3,UTRANS_FORWARD,parseError,status);
282
 
    if (transarray2[0] != 0) {
283
 
        ct1->adoptTransliterators(transarray2, 1);
284
 
    }
285
 
    if(ct1->getCount() != 1 || ct1->getID() != ID3){
286
 
        errln((UnicodeString)"Error: adoptTransliterators() failed.\n\t Count:- expected->1" + (UnicodeString)".  got->" + ct1->getCount() +
287
 
                                                   (UnicodeString)"\n\tID   :- expected->" + ID3 + (UnicodeString)".  got->" + ct1->getID());
288
 
    }
289
 
    else{
290
 
        logln("OK: adoptTranslterator() passed");
291
 
    }
292
 
    delete ct1;
293
 
    for(i=0;i<count;i++){
294
 
        delete transarray[i];
295
 
    }
296
 
    delete []transarray;
297
 
    delete []array;
298
 
}
299
 
 
300
 
/**
301
 
 * Splits a UnicodeString
302
 
 */
303
 
UnicodeString* CompoundTransliteratorTest::split(const UnicodeString& str, UChar seperator, int32_t& count) {
304
 
 
305
 
    //get the count
306
 
    int32_t i;
307
 
    count =1;
308
 
    for(i=0; i<str.length(); i++){
309
 
        if(str.charAt(i) == seperator)
310
 
            count++;
311
 
    }
312
 
    // make an array 
313
 
    UnicodeString* result = new UnicodeString[count];
314
 
    int32_t last = 0;
315
 
    int32_t current = 0;
316
 
    for (i = 0; i < str.length(); ++i) {
317
 
        if (str.charAt(i) == seperator) {
318
 
            str.extractBetween(last, i, result[current]);
319
 
            last = i+1;
320
 
            current++;
321
 
        }
322
 
    }
323
 
    str.extractBetween(last, i, result[current]);
324
 
    return result;
325
 
}
326
 
void CompoundTransliteratorTest::TestTransliterate(){
327
 
    logln("Testing the handleTransliterate() API of CompoundTransliterator");
328
 
    UErrorCode status = U_ZERO_ERROR;
329
 
    UParseError parseError;
330
 
    CompoundTransliterator *ct1=new CompoundTransliterator("Any-Hex;Hex-Any",parseError, status);
331
 
    if(U_FAILURE(status)){
332
 
        errln("CompoundTransliterator construction failed");
333
 
    }else {
334
 
        UnicodeString s("abcabc");
335
 
        expect(*ct1, s, s);
336
 
        UTransPosition index = { 0, 0, 0, 0 };
337
 
        UnicodeString rsource2(s);
338
 
        UnicodeString expectedResult=s;
339
 
        ct1->handleTransliterate(rsource2, index, FALSE);
340
 
        expectAux(ct1->getID() + ":String, index(0,0,0), incremental=FALSE", rsource2 + "->" + rsource2, rsource2==expectedResult, expectedResult);
341
 
        UTransPosition _index = {1,3,2,3};
342
 
        uprv_memcpy(&index, &_index, sizeof(index));
343
 
        UnicodeString rsource3(s);
344
 
        ct1->handleTransliterate(rsource3, index, TRUE); 
345
 
        expectAux(ct1->getID() + ":String, index(1,2,3), incremental=TRUE", rsource3 + "->" + rsource3, rsource3==expectedResult, expectedResult);
346
 
 
347
 
    }
348
 
    delete ct1;
349
 
    UnicodeString Data[]={
350
 
             //ID, input string, transliterated string
351
 
             "Any-Hex;Hex-Any;Any-Hex",     "hello",  UnicodeString("\\u0068\\u0065\\u006C\\u006C\\u006F", ""), 
352
 
             "Any-Hex;Hex-Any",                 "hello! How are you?",  "hello! How are you?",
353
 
             //"Devanagari-Latin;Latin-Devanagari",        CharsToUnicodeString("\\u092D\\u0948'\\u0930'\\u0935"),  CharsToUnicodeString("\\u092D\\u0948\\u0930\\u0935"), // quotes lost
354
 
             "Latin-Cyrillic;Cyrillic-Latin",           "a'b'k'd'e'f'g'h'i'j'Shch'shch'zh'h", "a'b'k'd'e'f'g'h'i'j'Shch'shch'zh'h", //"abkdefghijShchshchzhh",
355
 
             "Latin-Greek;Greek-Latin",                 "ABGabgAKLMN", "ABGabgAKLMN",
356
 
             //"Latin-Arabic;Arabic-Latin",               "Ad'r'a'b'i'k'dh'dd'gh", "Adrabikdhddgh",
357
 
             "Hiragana-Katakana",                       CharsToUnicodeString("\\u3041\\u308f\\u3099\\u306e\\u304b\\u3092\\u3099"), 
358
 
                                                                 CharsToUnicodeString("\\u30A1\\u30f7\\u30ce\\u30ab\\u30fa"),  
359
 
             "Hiragana-Katakana;Katakana-Hiragana",     CharsToUnicodeString("\\u3041\\u308f\\u3099\\u306e\\u304b\\u3051"), 
360
 
                                                                 CharsToUnicodeString("\\u3041\\u308f\\u3099\\u306e\\u304b\\u3051"),
361
 
             "Katakana-Hiragana;Hiragana-Katakana",     CharsToUnicodeString("\\u30A1\\u30f7\\u30ce\\u30f5\\u30f6"), 
362
 
                                                                 CharsToUnicodeString("\\u30A1\\u30f7\\u30ce\\u30ab\\u30b1"),  
363
 
             "Latin-Katakana;Katakana-Latin",                   CharsToUnicodeString("vavivuvevohuzizuzonyinyunyasesuzezu"), 
364
 
                                                                 CharsToUnicodeString("vavivuvevohuzizuzonyinyunyasesuzezu"),  
365
 
    };
366
 
    uint32_t i;
367
 
    for(i=0; i<sizeof(Data)/sizeof(Data[0]); i=i+3){
368
 
        UErrorCode status = U_ZERO_ERROR;
369
 
 
370
 
        CompoundTransliterator *ct2=new CompoundTransliterator(Data[i+0], parseError, status);
371
 
        if(U_FAILURE(status)){
372
 
            errln("CompoundTransliterator construction failed for " + Data[i+0]);
373
 
        } else {
374
 
            expect(*ct2, Data[i+1], Data[i+2]);
375
 
        }
376
 
        delete ct2;
377
 
    }
378
 
 
379
 
}
380
 
 
381
 
 
382
 
 
383
 
//======================================================================
384
 
// Support methods
385
 
//======================================================================
386
 
void CompoundTransliteratorTest::expect(const CompoundTransliterator& t,
387
 
                                const UnicodeString& source,
388
 
                                const UnicodeString& expectedResult) {
389
 
   
390
 
    UnicodeString rsource(source);
391
 
    t.transliterate(rsource);
392
 
    expectAux(t.getID() + ":Replaceable", source + "->" + rsource, rsource==expectedResult, expectedResult);
393
 
 
394
 
    // Test handleTransliterate (incremental) transliteration -- 
395
 
    rsource.remove();
396
 
    rsource.append(source);
397
 
    UTransPosition index;
398
 
    index.contextStart =0;
399
 
    index.contextLimit = source.length();
400
 
    index.start = 0;
401
 
    index.limit = source.length();
402
 
    t.handleTransliterate(rsource, index, TRUE);
403
 
    t.finishTransliteration(rsource,index);
404
 
    expectAux(t.getID() + ":handleTransliterate ", source + "->" + rsource, rsource==expectedResult, expectedResult);
405
 
 
406
 
}
407
 
 
408
 
void CompoundTransliteratorTest::expectAux(const UnicodeString& tag,
409
 
                                   const UnicodeString& summary, UBool pass,
410
 
                                   const UnicodeString& expectedResult) {
411
 
    if (pass) {
412
 
        logln(UnicodeString("(")+tag+") " + prettify(summary));
413
 
    } else {
414
 
        errln(UnicodeString("FAIL: (")+tag+") "
415
 
              + prettify(summary)
416
 
              + ", expected " + prettify(expectedResult));
417
 
    }
418
 
}
419