icuSources/test/perf/normperf/normperf.cpp

   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 "normperf.h"
  15 #include "uoptions.h"
  16 #include <stdio.h>
  17
  18 #define LENGTHOF(array) (sizeof(array)/sizeof((array)[0]))
  19
  20 UPerfFunction* NormalizerPerformanceTest::runIndexedTest(int32_t index, UBool exec,const char* &name, char* par) {
  21     switch (index) {
  22         TESTCASE(0,TestICU_NFC_NFD_Text);
  23         TESTCASE(1,TestICU_NFC_NFC_Text);
  24         TESTCASE(2,TestICU_NFC_Orig_Text);
  25
  26         TESTCASE(3,TestICU_NFD_NFD_Text);
  27         TESTCASE(4,TestICU_NFD_NFC_Text);
  28         TESTCASE(5,TestICU_NFD_Orig_Text);
  29
  30         TESTCASE(6,TestICU_FCD_NFD_Text);
  31         TESTCASE(7,TestICU_FCD_NFC_Text);
  32         TESTCASE(8,TestICU_FCD_Orig_Text);
  33
  34         TESTCASE(9,TestWin_NFC_NFD_Text);
  35         TESTCASE(10,TestWin_NFC_NFC_Text);
  36         TESTCASE(11,TestWin_NFC_Orig_Text);
  37
  38         TESTCASE(12,TestWin_NFD_NFD_Text);
  39         TESTCASE(13,TestWin_NFD_NFC_Text);
  40         TESTCASE(14,TestWin_NFD_Orig_Text);
  41
  42         TESTCASE(15,TestQC_NFC_NFD_Text);
  43         TESTCASE(16,TestQC_NFC_NFC_Text);
  44         TESTCASE(17,TestQC_NFC_Orig_Text);
  45
  46         TESTCASE(18,TestQC_NFD_NFD_Text);
  47         TESTCASE(19,TestQC_NFD_NFC_Text);
  48         TESTCASE(20,TestQC_NFD_Orig_Text);
  49
  50         TESTCASE(21,TestQC_FCD_NFD_Text);
  51         TESTCASE(22,TestQC_FCD_NFC_Text);
  52         TESTCASE(23,TestQC_FCD_Orig_Text);
  53
  54         TESTCASE(24,TestIsNormalized_NFC_NFD_Text);
  55         TESTCASE(25,TestIsNormalized_NFC_NFC_Text);
  56         TESTCASE(26,TestIsNormalized_NFC_Orig_Text);
  57
  58         TESTCASE(27,TestIsNormalized_NFD_NFD_Text);
  59         TESTCASE(28,TestIsNormalized_NFD_NFC_Text);
  60         TESTCASE(29,TestIsNormalized_NFD_Orig_Text);
  61
  62         TESTCASE(30,TestIsNormalized_FCD_NFD_Text);
  63         TESTCASE(31,TestIsNormalized_FCD_NFC_Text);
  64         TESTCASE(32,TestIsNormalized_FCD_Orig_Text);
  65
  66         default:
  67             name = "";
  68             return NULL;
  69     }
  70     return NULL;
  71
  72 }
  73
  74 void NormalizerPerformanceTest::normalizeInput(ULine* dest,const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options){
  75     int32_t reqLen = 0;
  76     UErrorCode status = U_ZERO_ERROR;
  77     for(;;){
  78         /* pure pre-flight */
  79         reqLen=unorm_normalize(src,srcLen,mode, options,NULL,0,&status);
  80         if(status==U_BUFFER_OVERFLOW_ERROR){
  81             status=U_ZERO_ERROR;
  82             dest->name = new UChar[reqLen+1];
  83             reqLen= unorm_normalize(src,srcLen,mode, options,dest->name,reqLen+1,&status);
  84             dest->len=reqLen;
  85             break;
  86         }else if(U_FAILURE(status)){
  87             printf("Could not normalize input. Error: %s", u_errorName(status));
  88         }
  89     }
  90 }
  91 UChar* NormalizerPerformanceTest::normalizeInput(int32_t& len, const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options){
  92     int32_t reqLen = 0;
  93     UErrorCode status = U_ZERO_ERROR;
  94     UChar* dest = NULL;
  95     for(;;){
  96         /* pure pre-flight */
  97         reqLen=unorm_normalize(src,srcLen,mode, options,NULL,0,&status);
  98         if(status==U_BUFFER_OVERFLOW_ERROR){
  99             status=U_ZERO_ERROR;
 100             dest = new UChar[reqLen+1];
 101             reqLen= unorm_normalize(src,srcLen,mode, options,dest,reqLen+1,&status);
 102             len=reqLen;
 103             break;
 104         }else if(U_FAILURE(status)){
 105             printf("Could not normalize input. Error: %s", u_errorName(status));
 106             return NULL;
 107         }
 108     }
 109     return dest;
 110 }
 111
 112 static UOption cmdLineOptions[]={
 113     UOPTION_DEF("options", 'o', UOPT_OPTIONAL_ARG)
 114 };
 115
 116 NormalizerPerformanceTest::NormalizerPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status)
 117 : UPerfTest(argc,argv,status), options(0) {
 118     NFDBuffer = NULL;
 119     NFCBuffer = NULL;
 120     NFDBufferLen = 0;
 121     NFCBufferLen = 0;
 122     NFDFileLines = NULL;
 123     NFCFileLines = NULL;
 124
 125     if(status== U_ILLEGAL_ARGUMENT_ERROR){
 126        fprintf(stderr,gUsageString, "normperf");
 127        return;
 128     }
 129
 130     if(U_FAILURE(status)){
 131         fprintf(stderr, "FAILED to create UPerfTest object. Error: %s\n", u_errorName(status));
 132         return;
 133     }
 134
 135     _remainingArgc = u_parseArgs(_remainingArgc, (char **)argv, (int32_t)(LENGTHOF(cmdLineOptions)), cmdLineOptions);
 136     if(cmdLineOptions[0].doesOccur && cmdLineOptions[0].value!=NULL) {
 137         options=(int32_t)strtol(cmdLineOptions[0].value, NULL, 16);
 138     }
 139
 140     if(line_mode){
 141         ULine* filelines = getLines(status);
 142         if(U_FAILURE(status)){
 143             fprintf(stderr, "FAILED to read lines from file and create UPerfTest object. Error: %s\n", u_errorName(status));
 144             return;
 145         }
 146         NFDFileLines = new ULine[numLines];
 147         NFCFileLines = new ULine[numLines];
 148
 149         for(int32_t i=0;i<numLines;i++){
 150             normalizeInput(&NFDFileLines[i],filelines[i].name,filelines[i].len,UNORM_NFD, options);
 151             normalizeInput(&NFCFileLines[i],filelines[i].name,filelines[i].len,UNORM_NFC, options);
 152
 153         }
 154     }else if(bulk_mode){
 155         int32_t srcLen = 0;
 156         const UChar* src = getBuffer(srcLen,status);
 157         NFDBufferLen = 0;
 158         NFCBufferLen = 0;
 159
 160         if(U_FAILURE(status)){
 161             fprintf(stderr, "FAILED to read buffer from file and create UPerfTest object. Error: %s\n", u_errorName(status));
 162             return;
 163         }
 164
 165         NFDBuffer = normalizeInput(NFDBufferLen,src,srcLen,UNORM_NFD, options);
 166         NFCBuffer = normalizeInput(NFCBufferLen,src,srcLen,UNORM_NFC, options);
 167     }
 168
 169 }
 170
 171 NormalizerPerformanceTest::~NormalizerPerformanceTest(){
 172     delete[] NFDFileLines;
 173     delete[] NFCFileLines;
 174     delete[] NFDBuffer;
 175     delete[] NFCBuffer;
 176 }
 177
 178 // Test NFC Performance
 179 UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_NFD_Text(){
 180     if(line_mode){
 181         NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFDFileLines,numLines, uselen);
 182         return func;
 183     }else{
 184         NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFDBuffer, NFDBufferLen, uselen);
 185         return func;
 186     }
 187 }
 188 UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_NFC_Text(){
 189     if(line_mode){
 190         NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,NFCFileLines,numLines, uselen);
 191         return func;
 192     }else{
 193         NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFCBuffer, NFCBufferLen, uselen);
 194         return func;
 195     }
 196 }
 197 UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_Orig_Text(){
 198     if(line_mode){
 199         NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,lines,numLines, uselen);
 200         return func;
 201     }else{
 202         NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,buffer, bufferLen, uselen);
 203         return func;
 204     }
 205 }
 206
 207 // Test NFD Performance
 208 UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_NFD_Text(){
 209     if(line_mode){
 210         NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFDFileLines,numLines, uselen);
 211         return func;
 212     }else{
 213         NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFDBuffer,NFDBufferLen, uselen);
 214         return func;
 215     }
 216 }
 217 UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_NFC_Text(){
 218     if(line_mode){
 219         NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFCFileLines,numLines, uselen);
 220         return func;
 221     }else{
 222         NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFCBuffer,NFCBufferLen, uselen);
 223         return func;
 224     }
 225 }
 226 UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_Orig_Text(){
 227     if(line_mode){
 228         NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,lines,numLines, uselen);
 229         return func;
 230     }else{
 231         NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,buffer,bufferLen, uselen);
 232         return func;
 233     }
 234 }
 235
 236 // Test FCD Performance
 237 UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_NFD_Text(){
 238     if(line_mode){
 239         NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFDFileLines,numLines, uselen);
 240         return func;
 241     }else{
 242         NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFDBuffer,NFDBufferLen, uselen);
 243         return func;
 244     }
 245
 246 }
 247 UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_NFC_Text(){
 248     if(line_mode){
 249         NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFCFileLines,numLines, uselen);
 250         return func;
 251     }else{
 252         NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFCBuffer,NFCBufferLen, uselen);
 253         return func;
 254     }
 255 }
 256 UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_Orig_Text(){
 257     if(line_mode){
 258         NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,lines,numLines, uselen);
 259         return func;
 260     }else{
 261         NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,buffer,bufferLen, uselen);
 262         return func;
 263     }
 264 }
 265
 266 // Test Win NFC Performance
 267 UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_NFD_Text(){
 268     if(line_mode){
 269         NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFDFileLines,numLines, uselen);
 270         return func;
 271     }else{
 272         NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFDBuffer,NFDBufferLen, uselen);
 273         return func;
 274     }
 275 }
 276 UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_NFC_Text(){
 277     if(line_mode){
 278         NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFCFileLines,numLines, uselen);
 279         return func;
 280     }else{
 281         NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFCBuffer,NFCBufferLen, uselen);
 282         return func;
 283     }
 284 }
 285 UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_Orig_Text(){
 286     if(line_mode){
 287         NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,lines,numLines, uselen);
 288         return func;
 289     }else{
 290         NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,buffer,bufferLen, uselen);
 291         return func;
 292     }
 293 }
 294
 295 // Test Win NFD Performance
 296 UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_NFD_Text(){
 297     if(line_mode){
 298         NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFDFileLines,numLines, uselen);
 299         return func;
 300     }else{
 301         NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFDBuffer,NFDBufferLen, uselen);
 302         return func;
 303     }
 304 }
 305 UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_NFC_Text(){
 306     if(line_mode){
 307         NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFCFileLines,numLines, uselen);
 308         return func;
 309     }else{
 310         NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFCBuffer,NFCBufferLen, uselen);
 311         return func;
 312     }
 313 }
 314 UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_Orig_Text(){
 315     if(line_mode){
 316         NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,lines,numLines, uselen);
 317         return func;
 318     }else{
 319         NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,buffer,bufferLen, uselen);
 320         return func;
 321     }
 322 }
 323
 324 // Test Quick Check Performance
 325 UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_NFD_Text(){
 326     if(line_mode){
 327         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_NFC, options,uselen);
 328         return func;
 329     }else{
 330         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_NFC, options,uselen);
 331         return func;
 332     }
 333 }
 334 UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_NFC_Text(){
 335     if(line_mode){
 336         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_NFC, options,uselen);
 337         return func;
 338     }else{
 339         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_NFC, options,uselen);
 340         return func;
 341     }
 342 }
 343 UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_Orig_Text(){
 344     if(line_mode){
 345         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_NFC, options,uselen);
 346         return func;
 347     }else{
 348         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_NFC, options,uselen);
 349         return func;
 350     }
 351 }
 352
 353 UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_NFD_Text(){
 354     if(line_mode){
 355         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_NFD, options,uselen);
 356         return func;
 357     }else{
 358         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_NFD, options,uselen);
 359         return func;
 360     }
 361 }
 362 UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_NFC_Text(){
 363     if(line_mode){
 364         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_NFD, options,uselen);
 365         return func;
 366     }else{
 367         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_NFD, options,uselen);
 368         return func;
 369     }
 370 }
 371 UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_Orig_Text(){
 372     if(line_mode){
 373         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_NFD, options,uselen);
 374         return func;
 375     }else{
 376         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_NFD, options,uselen);
 377         return func;
 378     }
 379 }
 380
 381 UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_NFD_Text(){
 382     if(line_mode){
 383         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_FCD, options,uselen);
 384         return func;
 385     }else{
 386         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_FCD, options,uselen);
 387         return func;
 388     }
 389 }
 390 UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_NFC_Text(){
 391     if(line_mode){
 392         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_FCD, options,uselen);
 393         return func;
 394     }else{
 395         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_FCD, options,uselen);
 396         return func;
 397     }
 398 }
 399 UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_Orig_Text(){
 400     if(line_mode){
 401         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_FCD, options,uselen);
 402         return func;
 403     }else{
 404         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_FCD, options,uselen);
 405         return func;
 406     }
 407 }
 408
 409 // Test isNormalized Performance
 410 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_NFD_Text(){
 411     if(line_mode){
 412         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_NFC, options,uselen);
 413         return func;
 414     }else{
 415         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_NFC, options,uselen);
 416         return func;
 417     }
 418 }
 419 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_NFC_Text(){
 420     if(line_mode){
 421         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_NFC, options,uselen);
 422         return func;
 423     }else{
 424         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_NFC, options,uselen);
 425         return func;
 426     }
 427 }
 428 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_Orig_Text(){
 429     if(line_mode){
 430         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_NFC, options,uselen);
 431         return func;
 432     }else{
 433         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_NFC, options,uselen);
 434         return func;
 435     }
 436 }
 437
 438 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_NFD_Text(){
 439     if(line_mode){
 440         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_NFD, options,uselen);
 441         return func;
 442     }else{
 443         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_NFD, options,uselen);
 444         return func;
 445     }
 446 }
 447 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_NFC_Text(){
 448     if(line_mode){
 449         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_NFD, options,uselen);
 450         return func;
 451     }else{
 452         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_NFD, options,uselen);
 453         return func;
 454     }
 455 }
 456 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_Orig_Text(){
 457     if(line_mode){
 458         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_NFD, options,uselen);
 459         return func;
 460     }else{
 461         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_NFD, options,uselen);
 462         return func;
 463     }
 464 }
 465
 466 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_NFD_Text(){
 467     if(line_mode){
 468         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_FCD, options,uselen);
 469         return func;
 470     }else{
 471         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_FCD, options,uselen);
 472         return func;
 473     }
 474 }
 475 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_NFC_Text(){
 476     if(line_mode){
 477         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_FCD, options,uselen);
 478         return func;
 479     }else{
 480         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_FCD, options,uselen);
 481         return func;
 482     }
 483 }
 484 UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_Orig_Text(){
 485     if(line_mode){
 486         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_FCD, options,uselen);
 487         return func;
 488     }else{
 489         QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_FCD, options,uselen);
 490         return func;
 491     }
 492 }
 493
 494 int main(int argc, const char* argv[]){
 495     UErrorCode status = U_ZERO_ERROR;
 496     NormalizerPerformanceTest test(argc, argv, status);
 497     if(U_FAILURE(status)){
 498         return status;
 499     }
 500     if(test.run()==FALSE){
 501         fprintf(stderr,"FAILED: Tests could not be run please check the arguments.\n");
 502         return -1;
 503     }
 504     return 0;
 505 }