icuSources/test/perf/normperf/normperf.cpp

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