Home | History | Annotate | Download | only in convperf 
      1 /*
      2 **********************************************************************
      3 * Copyright (c) 2002-2005, International Business Machines
      4 * Corporation and others.  All Rights Reserved.
      5 **********************************************************************
      6 **********************************************************************
      7 */
      8 /**
      9  * This Program tests the performance of ICU's Normalization engine against Windows
     10  * to run it use the command like
     11  *
     12  * c:\normperf.exe -s C:\work\ICUCupertinoRep\icu4c\collation-perf-data  -i 10 -p 15 -f TestNames_Asian.txt -u -e UTF-8  -l
     13  */
     14 #include "convperf.h"
     15 #include "data.h"
     16 #include <stdio.h>
     17 
     18 int main(int argc, const char* argv[]){
     19     UErrorCode status = U_ZERO_ERROR;
     20     ConverterPerformanceTest test(argc, argv, status);
     21     if(U_FAILURE(status)){
     22         return status;
     23     }
     24     if(test.run()==FALSE){
     25         fprintf(stderr,"FAILED: Tests could not be run please check the arguments.\n");
     26         return -1;
     27     }
     28     return 0;
     29 }
     30 
     31 
     32 ConverterPerformanceTest::ConverterPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status)
     33 : UPerfTest(argc,argv,status){
     34 
     35 }
     36 
     37 ConverterPerformanceTest::~ConverterPerformanceTest(){
     38 
     39 }
     40 
     41 UPerfFunction* ConverterPerformanceTest::runIndexedTest(int32_t index, UBool exec,const char* &name, char* par) {
     42     switch (index) {
     43         TESTCASE(0,TestICU_CleanOpenAllConverters);// This calls u_cleanup()
     44         TESTCASE(1,TestICU_OpenAllConverters);// This doesn't call u_cleanup()
     45 
     46         TESTCASE(2,TestICU_UTF8_ToUnicode);
     47         TESTCASE(3,TestICU_UTF8_FromUnicode);
     48         TESTCASE(4,TestWinANSI_UTF8_ToUnicode);
     49         TESTCASE(5,TestWinANSI_UTF8_FromUnicode);
     50         TESTCASE(6,TestWinIML2_UTF8_ToUnicode);
     51         TESTCASE(7,TestWinIML2_UTF8_FromUnicode);
     52 
     53         TESTCASE(8,TestICU_Latin1_ToUnicode);
     54         TESTCASE(9,TestICU_Latin1_FromUnicode);
     55         TESTCASE(10,TestWinIML2_Latin1_ToUnicode);
     56         TESTCASE(11,TestWinIML2_Latin1_FromUnicode);
     57 
     58         TESTCASE(12,TestICU_Latin8_ToUnicode);
     59         TESTCASE(13,TestICU_Latin8_FromUnicode);
     60         TESTCASE(14,TestWinIML2_Latin8_ToUnicode);
     61         TESTCASE(15,TestWinIML2_Latin8_FromUnicode);
     62 
     63         TESTCASE(16,TestICU_EBCDIC_Arabic_ToUnicode);
     64         TESTCASE(17,TestICU_EBCDIC_Arabic_FromUnicode);
     65         TESTCASE(18,TestWinIML2_EBCDIC_Arabic_ToUnicode);
     66         TESTCASE(19,TestWinIML2_EBCDIC_Arabic_FromUnicode);
     67 
     68         TESTCASE(20,TestICU_SJIS_ToUnicode);
     69         TESTCASE(21,TestICU_SJIS_FromUnicode);
     70         TESTCASE(22,TestWinIML2_SJIS_ToUnicode);
     71         TESTCASE(23,TestWinIML2_SJIS_FromUnicode);
     72 
     73         TESTCASE(24,TestICU_EUCJP_ToUnicode);
     74         TESTCASE(25,TestICU_EUCJP_FromUnicode);
     75         TESTCASE(26,TestWinIML2_EUCJP_ToUnicode);
     76         TESTCASE(27,TestWinIML2_EUCJP_FromUnicode);
     77 
     78         TESTCASE(28,TestICU_GB2312_FromUnicode);
     79         TESTCASE(29,TestICU_GB2312_ToUnicode);
     80         TESTCASE(30,TestWinIML2_GB2312_ToUnicode);
     81         TESTCASE(31,TestWinIML2_GB2312_FromUnicode);
     82 
     83         TESTCASE(32,TestICU_ISO2022KR_ToUnicode);
     84         TESTCASE(33,TestICU_ISO2022KR_FromUnicode);
     85         TESTCASE(34,TestWinIML2_ISO2022KR_ToUnicode);
     86         TESTCASE(35,TestWinIML2_ISO2022KR_FromUnicode);
     87 
     88         TESTCASE(36,TestICU_ISO2022JP_ToUnicode);
     89         TESTCASE(37,TestICU_ISO2022JP_FromUnicode);
     90         TESTCASE(38,TestWinIML2_ISO2022JP_ToUnicode);
     91         TESTCASE(39,TestWinIML2_ISO2022JP_FromUnicode);
     92 
     93         TESTCASE(40,TestWinANSI_Latin1_ToUnicode);
     94         TESTCASE(41,TestWinANSI_Latin1_FromUnicode);
     95 
     96         TESTCASE(42,TestWinANSI_Latin8_ToUnicode);
     97         TESTCASE(43,TestWinANSI_Latin8_FromUnicode);
     98 
     99         TESTCASE(44,TestWinANSI_SJIS_ToUnicode);
    100         TESTCASE(45,TestWinANSI_SJIS_FromUnicode);
    101 
    102         TESTCASE(46,TestWinANSI_EUCJP_ToUnicode);
    103         TESTCASE(47,TestWinANSI_EUCJP_FromUnicode);
    104 
    105         TESTCASE(48,TestWinANSI_GB2312_ToUnicode);
    106         TESTCASE(49,TestWinANSI_GB2312_FromUnicode);
    107 
    108         TESTCASE(50,TestWinANSI_ISO2022KR_ToUnicode);
    109         TESTCASE(51,TestWinANSI_ISO2022KR_FromUnicode);
    110 
    111         TESTCASE(52,TestWinANSI_ISO2022JP_ToUnicode);
    112         TESTCASE(53,TestWinANSI_ISO2022JP_FromUnicode);
    113 
    114         default:
    115             name = "";
    116             return NULL;
    117     }
    118     return NULL;
    119 
    120 }
    121 
    122 UPerfFunction* ConverterPerformanceTest::TestICU_CleanOpenAllConverters() {
    123     UErrorCode status = U_ZERO_ERROR;
    124     UPerfFunction* pf = new ICUOpenAllConvertersFunction(TRUE, status);
    125     if(U_FAILURE(status)){
    126         return NULL;
    127     }
    128     return pf;
    129 }
    130 
    131 UPerfFunction* ConverterPerformanceTest::TestICU_OpenAllConverters() {
    132     UErrorCode status = U_ZERO_ERROR;
    133     UPerfFunction* pf = new ICUOpenAllConvertersFunction(FALSE, status);
    134     if(U_FAILURE(status)){
    135         return NULL;
    136     }
    137     return pf;
    138 }
    139 
    140 UPerfFunction* ConverterPerformanceTest::TestICU_UTF8_FromUnicode(){
    141     UErrorCode status = U_ZERO_ERROR;
    142     ICUFromUnicodePerfFunction* pf = new ICUFromUnicodePerfFunction("utf-8",utf8_uniSource, LENGTHOF(utf8_uniSource), status);
    143     if(U_FAILURE(status)){
    144         return NULL;
    145     }
    146     return pf;
    147 }
    148 
    149 UPerfFunction*  ConverterPerformanceTest::TestICU_UTF8_ToUnicode(){
    150     UErrorCode status = U_ZERO_ERROR;
    151     UPerfFunction* pf = new ICUToUnicodePerfFunction("utf-8",(char*)utf8_encSource, LENGTHOF(utf8_encSource), status);
    152     if(U_FAILURE(status)){
    153         return NULL;
    154     }
    155     return pf;
    156 }
    157 
    158 
    159 UPerfFunction* ConverterPerformanceTest::TestWinIML2_UTF8_FromUnicode(){
    160     UErrorCode status = U_ZERO_ERROR;
    161     UPerfFunction* pf = new WinIMultiLanguage2FromUnicodePerfFunction("utf-8",utf8_uniSource, LENGTHOF(utf8_uniSource), status);
    162     if(U_FAILURE(status)){
    163         return NULL;
    164     }
    165     return pf;
    166 }
    167 
    168 UPerfFunction*  ConverterPerformanceTest::TestWinIML2_UTF8_ToUnicode(){
    169     UErrorCode status = U_ZERO_ERROR;
    170     UPerfFunction* pf = new WinIMultiLanguage2ToUnicodePerfFunction("utf-8",(char*)utf8_encSource, LENGTHOF(utf8_encSource), status);
    171     if(U_FAILURE(status)){
    172         return NULL;
    173     }
    174     return pf;
    175 }
    176 
    177 UPerfFunction* ConverterPerformanceTest::TestWinANSI_UTF8_FromUnicode(){
    178     UErrorCode status = U_ZERO_ERROR;
    179     UPerfFunction* pf = new WinANSIFromUnicodePerfFunction("utf-8",utf8_uniSource, LENGTHOF(utf8_uniSource), status);
    180     if(U_FAILURE(status)){
    181         return NULL;
    182     }
    183     return pf;
    184 }
    185 
    186 UPerfFunction*  ConverterPerformanceTest::TestWinANSI_UTF8_ToUnicode(){
    187     UErrorCode status = U_ZERO_ERROR;
    188     UPerfFunction* pf = new WinANSIToUnicodePerfFunction("utf-8",(char*)utf8_encSource, LENGTHOF(utf8_encSource), status);
    189     if(U_FAILURE(status)){
    190         return NULL;
    191     }
    192     return pf;
    193 }
    194 
    195 //################
    196 
    197 UPerfFunction* ConverterPerformanceTest::TestICU_Latin1_FromUnicode(){
    198     UErrorCode status = U_ZERO_ERROR;
    199     ICUFromUnicodePerfFunction* pf = new ICUFromUnicodePerfFunction("iso-8859-1",latin1_uniSource, LENGTHOF(latin1_uniSource), status);
    200     if(U_FAILURE(status)){
    201         return NULL;
    202     }
    203     return pf;
    204 }
    205 
    206 UPerfFunction*  ConverterPerformanceTest::TestICU_Latin1_ToUnicode(){
    207     UErrorCode status = U_ZERO_ERROR;
    208     UPerfFunction* pf = new ICUToUnicodePerfFunction("iso-8859-1",(char*)latin1_encSource, LENGTHOF(latin1_encSource), status);
    209     if(U_FAILURE(status)){
    210         return NULL;
    211     }
    212     return pf;
    213 }
    214 
    215 
    216 UPerfFunction* ConverterPerformanceTest::TestWinIML2_Latin1_FromUnicode(){
    217     UErrorCode status = U_ZERO_ERROR;
    218     UPerfFunction* pf = new WinIMultiLanguage2FromUnicodePerfFunction("iso-8859-1",latin1_uniSource, LENGTHOF(latin1_uniSource), status);
    219     if(U_FAILURE(status)){
    220         return NULL;
    221     }
    222     return pf;
    223 }
    224 
    225 UPerfFunction*  ConverterPerformanceTest::TestWinIML2_Latin1_ToUnicode(){
    226     UErrorCode status = U_ZERO_ERROR;
    227     UPerfFunction* pf = new WinIMultiLanguage2ToUnicodePerfFunction("iso-8859-1",(char*)latin1_encSource, LENGTHOF(latin1_encSource), status);
    228     if(U_FAILURE(status)){
    229         return NULL;
    230     }
    231     return pf;
    232 }
    233 
    234 UPerfFunction* ConverterPerformanceTest::TestWinANSI_Latin1_FromUnicode(){
    235     UErrorCode status = U_ZERO_ERROR;
    236     UPerfFunction* pf = new WinANSIFromUnicodePerfFunction("iso-8859-1",latin1_uniSource, LENGTHOF(latin1_uniSource), status);
    237     if(U_FAILURE(status)){
    238         return NULL;
    239     }
    240     return pf;
    241 }
    242 
    243 UPerfFunction*  ConverterPerformanceTest::TestWinANSI_Latin1_ToUnicode(){
    244     UErrorCode status = U_ZERO_ERROR;
    245     UPerfFunction* pf = new WinANSIToUnicodePerfFunction("iso-8859-1",(char*)latin1_encSource, LENGTHOF(latin1_encSource), status);
    246     if(U_FAILURE(status)){
    247         return NULL;
    248     }
    249     return pf;
    250 }
    251 
    252 //##################
    253 
    254 UPerfFunction* ConverterPerformanceTest::TestICU_Latin8_FromUnicode(){
    255     UErrorCode status = U_ZERO_ERROR;
    256     ICUFromUnicodePerfFunction* pf = new ICUFromUnicodePerfFunction("iso-8859-8",latin8_uniSource, LENGTHOF(latin8_uniSource), status);
    257     if(U_FAILURE(status)){
    258         return NULL;
    259     }
    260     return pf;
    261 }
    262 
    263 UPerfFunction*  ConverterPerformanceTest::TestICU_Latin8_ToUnicode(){
    264     UErrorCode status = U_ZERO_ERROR;
    265     UPerfFunction* pf = new ICUToUnicodePerfFunction("iso-8859-8",(char*)latin8_encSource, LENGTHOF(latin8_encSource), status);
    266     if(U_FAILURE(status)){
    267         return NULL;
    268     }
    269     return pf;
    270 }
    271 
    272 
    273 UPerfFunction* ConverterPerformanceTest::TestWinIML2_Latin8_FromUnicode(){
    274     UErrorCode status = U_ZERO_ERROR;
    275     UPerfFunction* pf = new WinIMultiLanguage2FromUnicodePerfFunction("iso-8859-8",latin8_uniSource, LENGTHOF(latin8_uniSource), status);
    276     if(U_FAILURE(status)){
    277         return NULL;
    278     }
    279     return pf;
    280 }
    281 
    282 UPerfFunction*  ConverterPerformanceTest::TestWinIML2_Latin8_ToUnicode(){
    283     UErrorCode status = U_ZERO_ERROR;
    284     UPerfFunction* pf = new WinIMultiLanguage2ToUnicodePerfFunction("iso-8859-8",(char*)latin8_encSource, LENGTHOF(latin8_encSource), status);
    285     if(U_FAILURE(status)){
    286         return NULL;
    287     }
    288     return pf;
    289 }
    290 UPerfFunction* ConverterPerformanceTest::TestWinANSI_Latin8_FromUnicode(){
    291     UErrorCode status = U_ZERO_ERROR;
    292     UPerfFunction* pf = new WinANSIFromUnicodePerfFunction("iso-8859-8",latin8_uniSource, LENGTHOF(latin8_uniSource), status);
    293     if(U_FAILURE(status)){
    294         return NULL;
    295     }
    296     return pf;
    297 }
    298 
    299 UPerfFunction*  ConverterPerformanceTest::TestWinANSI_Latin8_ToUnicode(){
    300     UErrorCode status = U_ZERO_ERROR;
    301     UPerfFunction* pf = new WinANSIToUnicodePerfFunction("iso-8859-8",(char*)latin8_encSource, LENGTHOF(latin8_encSource), status);
    302     if(U_FAILURE(status)){
    303         return NULL;
    304     }
    305     return pf;
    306 }
    307 
    308 //#################
    309 
    310 
    311 UPerfFunction* ConverterPerformanceTest::TestICU_EBCDIC_Arabic_FromUnicode(){
    312     UErrorCode status = U_ZERO_ERROR;
    313     ICUFromUnicodePerfFunction* pf = new ICUFromUnicodePerfFunction("x-EBCDIC-Arabic",ebcdic_arabic_uniSource, LENGTHOF(ebcdic_arabic_uniSource), status);
    314     if(U_FAILURE(status)){
    315         return NULL;
    316     }
    317     return pf;
    318 }
    319 
    320 UPerfFunction*  ConverterPerformanceTest::TestICU_EBCDIC_Arabic_ToUnicode(){
    321     UErrorCode status = U_ZERO_ERROR;
    322     UPerfFunction* pf = new ICUToUnicodePerfFunction("x-EBCDIC-Arabic",(char*)ebcdic_arabic_encSource, LENGTHOF(ebcdic_arabic_encSource), status);
    323     if(U_FAILURE(status)){
    324         return NULL;
    325     }
    326     return pf;
    327 }
    328 
    329 
    330 UPerfFunction* ConverterPerformanceTest::TestWinIML2_EBCDIC_Arabic_FromUnicode(){
    331     UErrorCode status = U_ZERO_ERROR;
    332     UPerfFunction* pf = new WinIMultiLanguage2FromUnicodePerfFunction("x-EBCDIC-Arabic",ebcdic_arabic_uniSource, LENGTHOF(ebcdic_arabic_uniSource), status);
    333     if(U_FAILURE(status)){
    334         return NULL;
    335     }
    336     return pf;
    337 }
    338 
    339 UPerfFunction*  ConverterPerformanceTest::TestWinIML2_EBCDIC_Arabic_ToUnicode(){
    340     UErrorCode status = U_ZERO_ERROR;
    341     UPerfFunction* pf = new WinIMultiLanguage2ToUnicodePerfFunction("x-EBCDIC-Arabic",(char*)ebcdic_arabic_encSource, LENGTHOF(ebcdic_arabic_encSource), status);
    342     if(U_FAILURE(status)){
    343         return NULL;
    344     }
    345     return pf;
    346 }
    347 
    348 UPerfFunction* ConverterPerformanceTest::TestWinANSI_EBCDIC_Arabic_FromUnicode(){
    349     UErrorCode status = U_ZERO_ERROR;
    350     UPerfFunction* pf = new WinANSIFromUnicodePerfFunction("x-EBCDIC-Arabic",ebcdic_arabic_uniSource, LENGTHOF(ebcdic_arabic_uniSource), status);
    351     if(U_FAILURE(status)){
    352         return NULL;
    353     }
    354     return pf;
    355 }
    356 
    357 UPerfFunction*  ConverterPerformanceTest::TestWinANSI_EBCDIC_Arabic_ToUnicode(){
    358     UErrorCode status = U_ZERO_ERROR;
    359     UPerfFunction* pf = new WinANSIToUnicodePerfFunction("x-EBCDIC-Arabic",(char*)ebcdic_arabic_encSource, LENGTHOF(ebcdic_arabic_encSource), status);
    360     if(U_FAILURE(status)){
    361         return NULL;
    362     }
    363     return pf;
    364 }
    365 //#################
    366 
    367 
    368 UPerfFunction* ConverterPerformanceTest::TestICU_SJIS_FromUnicode(){
    369     UErrorCode status = U_ZERO_ERROR;
    370     ICUFromUnicodePerfFunction* pf = new ICUFromUnicodePerfFunction("sjis",sjis_uniSource, LENGTHOF(sjis_uniSource), status);
    371     if(U_FAILURE(status)){
    372         return NULL;
    373     }
    374     return pf;
    375 }
    376 
    377 UPerfFunction*  ConverterPerformanceTest::TestICU_SJIS_ToUnicode(){
    378     UErrorCode status = U_ZERO_ERROR;
    379     UPerfFunction* pf = new ICUToUnicodePerfFunction("sjis",(char*)sjis_encSource, LENGTHOF(sjis_encSource), status);
    380     if(U_FAILURE(status)){
    381         return NULL;
    382     }
    383     return pf;
    384 }
    385 
    386 
    387 UPerfFunction* ConverterPerformanceTest::TestWinIML2_SJIS_FromUnicode(){
    388     UErrorCode status = U_ZERO_ERROR;
    389     UPerfFunction* pf = new WinIMultiLanguage2FromUnicodePerfFunction("sjis",sjis_uniSource, LENGTHOF(sjis_uniSource), status);
    390     if(U_FAILURE(status)){
    391         return NULL;
    392     }
    393     return pf;
    394 }
    395 
    396 UPerfFunction*  ConverterPerformanceTest::TestWinIML2_SJIS_ToUnicode(){
    397     UErrorCode status = U_ZERO_ERROR;
    398     UPerfFunction* pf = new WinIMultiLanguage2ToUnicodePerfFunction("sjis",(char*)sjis_encSource, LENGTHOF(sjis_encSource), status);
    399     if(U_FAILURE(status)){
    400         return NULL;
    401     }
    402     return pf;
    403 }
    404 
    405 UPerfFunction* ConverterPerformanceTest::TestWinANSI_SJIS_FromUnicode(){
    406     UErrorCode status = U_ZERO_ERROR;
    407     UPerfFunction* pf = new WinANSIFromUnicodePerfFunction("sjis",sjis_uniSource, LENGTHOF(sjis_uniSource), status);
    408     if(U_FAILURE(status)){
    409         return NULL;
    410     }
    411     return pf;
    412 }
    413 
    414 UPerfFunction*  ConverterPerformanceTest::TestWinANSI_SJIS_ToUnicode(){
    415     UErrorCode status = U_ZERO_ERROR;
    416     UPerfFunction* pf = new WinANSIToUnicodePerfFunction("sjis",(char*)sjis_encSource, LENGTHOF(sjis_encSource), status);
    417     if(U_FAILURE(status)){
    418         return NULL;
    419     }
    420     return pf;
    421 }
    422 
    423 
    424 //#################
    425 
    426 
    427 UPerfFunction* ConverterPerformanceTest::TestICU_EUCJP_FromUnicode(){
    428     UErrorCode status = U_ZERO_ERROR;
    429     ICUFromUnicodePerfFunction* pf = new ICUFromUnicodePerfFunction("euc-jp",eucjp_uniSource, LENGTHOF(eucjp_uniSource), status);
    430     if(U_FAILURE(status)){
    431         return NULL;
    432     }
    433     return pf;
    434 }
    435 
    436 UPerfFunction*  ConverterPerformanceTest::TestICU_EUCJP_ToUnicode(){
    437     UErrorCode status = U_ZERO_ERROR;
    438     UPerfFunction* pf = new ICUToUnicodePerfFunction("euc-jp",(char*)eucjp_encSource, LENGTHOF(eucjp_encSource), status);
    439     if(U_FAILURE(status)){
    440         return NULL;
    441     }
    442     return pf;
    443 }
    444 
    445 
    446 UPerfFunction* ConverterPerformanceTest::TestWinIML2_EUCJP_FromUnicode(){
    447     UErrorCode status = U_ZERO_ERROR;
    448     UPerfFunction* pf = new WinIMultiLanguage2FromUnicodePerfFunction("euc-jp",eucjp_uniSource, LENGTHOF(eucjp_uniSource), status);
    449     if(U_FAILURE(status)){
    450         return NULL;
    451     }
    452     return pf;
    453 }
    454 
    455 UPerfFunction*  ConverterPerformanceTest::TestWinIML2_EUCJP_ToUnicode(){
    456     UErrorCode status = U_ZERO_ERROR;
    457     UPerfFunction* pf = new WinIMultiLanguage2ToUnicodePerfFunction("euc-jp",(char*)eucjp_encSource, LENGTHOF(eucjp_encSource), status);
    458     if(U_FAILURE(status)){
    459         return NULL;
    460     }
    461     return pf;
    462 }
    463 
    464 UPerfFunction* ConverterPerformanceTest::TestWinANSI_EUCJP_FromUnicode(){
    465     UErrorCode status = U_ZERO_ERROR;
    466     UPerfFunction* pf = new WinANSIFromUnicodePerfFunction("euc-jp",eucjp_uniSource, LENGTHOF(eucjp_uniSource), status);
    467     if(U_FAILURE(status)){
    468         return NULL;
    469     }
    470     return pf;
    471 }
    472 
    473 UPerfFunction*  ConverterPerformanceTest::TestWinANSI_EUCJP_ToUnicode(){
    474     UErrorCode status = U_ZERO_ERROR;
    475     UPerfFunction* pf = new WinANSIToUnicodePerfFunction("euc-jp",(char*)eucjp_encSource, LENGTHOF(eucjp_encSource), status);
    476     if(U_FAILURE(status)){
    477         return NULL;
    478     }
    479     return pf;
    480 }
    481 
    482 
    483 //#################
    484 
    485 
    486 UPerfFunction* ConverterPerformanceTest::TestICU_GB2312_FromUnicode(){
    487     UErrorCode status = U_ZERO_ERROR;
    488     ICUFromUnicodePerfFunction* pf = new ICUFromUnicodePerfFunction("gb2312",gb2312_uniSource, LENGTHOF(gb2312_uniSource), status);
    489     if(U_FAILURE(status)){
    490         return NULL;
    491     }
    492     return pf;
    493 }
    494 
    495 UPerfFunction*  ConverterPerformanceTest::TestICU_GB2312_ToUnicode(){
    496     UErrorCode status = U_ZERO_ERROR;
    497     UPerfFunction* pf = new ICUToUnicodePerfFunction("gb2312",(char*)gb2312_encSource, LENGTHOF(gb2312_encSource), status);
    498     if(U_FAILURE(status)){
    499         return NULL;
    500     }
    501     return pf;
    502 }
    503 
    504 
    505 UPerfFunction* ConverterPerformanceTest::TestWinIML2_GB2312_FromUnicode(){
    506     UErrorCode status = U_ZERO_ERROR;
    507     UPerfFunction* pf = new WinIMultiLanguage2FromUnicodePerfFunction("gb2312",gb2312_uniSource, LENGTHOF(gb2312_uniSource), status);
    508     if(U_FAILURE(status)){
    509         return NULL;
    510     }
    511     return pf;
    512 }
    513 
    514 UPerfFunction*  ConverterPerformanceTest::TestWinIML2_GB2312_ToUnicode(){
    515     UErrorCode status = U_ZERO_ERROR;
    516     UPerfFunction* pf = new WinIMultiLanguage2ToUnicodePerfFunction("gb2312",(char*)gb2312_encSource, LENGTHOF(gb2312_encSource), status);
    517     if(U_FAILURE(status)){
    518         return NULL;
    519     }
    520     return pf;
    521 }
    522 
    523 UPerfFunction* ConverterPerformanceTest::TestWinANSI_GB2312_FromUnicode(){
    524     UErrorCode status = U_ZERO_ERROR;
    525     UPerfFunction* pf = new WinANSIFromUnicodePerfFunction("gb2312",gb2312_uniSource, LENGTHOF(gb2312_uniSource), status);
    526     if(U_FAILURE(status)){
    527         return NULL;
    528     }
    529     return pf;
    530 }
    531 
    532 UPerfFunction*  ConverterPerformanceTest::TestWinANSI_GB2312_ToUnicode(){
    533     UErrorCode status = U_ZERO_ERROR;
    534     UPerfFunction* pf = new WinANSIToUnicodePerfFunction("gb2312",(char*)gb2312_encSource, LENGTHOF(gb2312_encSource), status);
    535     if(U_FAILURE(status)){
    536         return NULL;
    537     }
    538     return pf;
    539 }
    540 
    541 //#################
    542 
    543 
    544 UPerfFunction* ConverterPerformanceTest::TestICU_ISO2022KR_FromUnicode(){
    545     UErrorCode status = U_ZERO_ERROR;
    546     ICUFromUnicodePerfFunction* pf = new ICUFromUnicodePerfFunction("iso-2022-kr",iso2022kr_uniSource, LENGTHOF(iso2022kr_uniSource), status);
    547     if(U_FAILURE(status)){
    548         return NULL;
    549     }
    550     return pf;
    551 }
    552 
    553 UPerfFunction*  ConverterPerformanceTest::TestICU_ISO2022KR_ToUnicode(){
    554     UErrorCode status = U_ZERO_ERROR;
    555     UPerfFunction* pf = new ICUToUnicodePerfFunction("iso-2022-kr",(char*)iso2022kr_encSource, LENGTHOF(iso2022kr_encSource), status);
    556     if(U_FAILURE(status)){
    557         return NULL;
    558     }
    559     return pf;
    560 }
    561 
    562 
    563 UPerfFunction* ConverterPerformanceTest::TestWinIML2_ISO2022KR_FromUnicode(){
    564     UErrorCode status = U_ZERO_ERROR;
    565     UPerfFunction* pf = new WinIMultiLanguage2FromUnicodePerfFunction("iso-2022-kr",iso2022kr_uniSource, LENGTHOF(iso2022kr_uniSource), status);
    566     if(U_FAILURE(status)){
    567         return NULL;
    568     }
    569     return pf;
    570 }
    571 
    572 UPerfFunction*  ConverterPerformanceTest::TestWinIML2_ISO2022KR_ToUnicode(){
    573     UErrorCode status = U_ZERO_ERROR;
    574     UPerfFunction* pf = new WinIMultiLanguage2ToUnicodePerfFunction("iso-2022-kr",(char*)iso2022kr_encSource, LENGTHOF(iso2022kr_encSource), status);
    575     if(U_FAILURE(status)){
    576         return NULL;
    577     }
    578     return pf;
    579 }
    580 
    581 UPerfFunction* ConverterPerformanceTest::TestWinANSI_ISO2022KR_FromUnicode(){
    582     UErrorCode status = U_ZERO_ERROR;
    583     UPerfFunction* pf = new WinANSIFromUnicodePerfFunction("iso-2022-kr",iso2022kr_uniSource, LENGTHOF(iso2022kr_uniSource), status);
    584     if(U_FAILURE(status)){
    585         return NULL;
    586     }
    587     return pf;
    588 }
    589 
    590 UPerfFunction*  ConverterPerformanceTest::TestWinANSI_ISO2022KR_ToUnicode(){
    591     UErrorCode status = U_ZERO_ERROR;
    592     UPerfFunction* pf = new WinANSIToUnicodePerfFunction("iso-2022-kr",(char*)iso2022kr_encSource, LENGTHOF(iso2022kr_encSource), status);
    593     if(U_FAILURE(status)){
    594         return NULL;
    595     }
    596     return pf;
    597 }
    598 //#################
    599 
    600 
    601 UPerfFunction* ConverterPerformanceTest::TestICU_ISO2022JP_FromUnicode(){
    602     UErrorCode status = U_ZERO_ERROR;
    603     ICUFromUnicodePerfFunction* pf = new ICUFromUnicodePerfFunction("iso-2022-jp",iso2022jp_uniSource, LENGTHOF(iso2022jp_uniSource), status);
    604     if(U_FAILURE(status)){
    605         return NULL;
    606     }
    607     return pf;
    608 }
    609 
    610 UPerfFunction*  ConverterPerformanceTest::TestICU_ISO2022JP_ToUnicode(){
    611     UErrorCode status = U_ZERO_ERROR;
    612     UPerfFunction* pf = new ICUToUnicodePerfFunction("iso-2022-jp",(char*)iso2022jp_encSource, LENGTHOF(iso2022jp_encSource), status);
    613     if(U_FAILURE(status)){
    614         return NULL;
    615     }
    616     return pf;
    617 }
    618 
    619 
    620 UPerfFunction* ConverterPerformanceTest::TestWinIML2_ISO2022JP_FromUnicode(){
    621     UErrorCode status = U_ZERO_ERROR;
    622     UPerfFunction* pf = new WinIMultiLanguage2FromUnicodePerfFunction("iso-2022-jp",iso2022jp_uniSource, LENGTHOF(iso2022jp_uniSource), status);
    623     if(U_FAILURE(status)){
    624         return NULL;
    625     }
    626     return pf;
    627 }
    628 
    629 UPerfFunction*  ConverterPerformanceTest::TestWinIML2_ISO2022JP_ToUnicode(){
    630     UErrorCode status = U_ZERO_ERROR;
    631     UPerfFunction* pf = new WinIMultiLanguage2ToUnicodePerfFunction("iso-2022-jp",(char*)iso2022jp_encSource, LENGTHOF(iso2022jp_encSource), status);
    632     if(U_FAILURE(status)){
    633         return NULL;
    634     }
    635     return pf;
    636 }
    637 
    638 UPerfFunction* ConverterPerformanceTest::TestWinANSI_ISO2022JP_FromUnicode(){
    639     UErrorCode status = U_ZERO_ERROR;
    640     UPerfFunction* pf = new WinANSIFromUnicodePerfFunction("iso-2022-jp",iso2022jp_uniSource, LENGTHOF(iso2022jp_uniSource), status);
    641     if(U_FAILURE(status)){
    642         return NULL;
    643     }
    644     return pf;
    645 }
    646 
    647 UPerfFunction*  ConverterPerformanceTest::TestWinANSI_ISO2022JP_ToUnicode(){
    648     UErrorCode status = U_ZERO_ERROR;
    649     UPerfFunction* pf = new WinANSIToUnicodePerfFunction("iso-2022-jp",(char*)iso2022jp_encSource, LENGTHOF(iso2022jp_encSource), status);
    650     if(U_FAILURE(status)){
    651         return NULL;
    652     }
    653     return pf;
    654 }