[apple/icu.git] / icuSources / test / perf / normperf / normperf.cpp

/*
***********************************************************************
* © 2016 and later: Unicode, Inc. and others.
* License & terms of use: http://www.unicode.org/copyright.html#License
***********************************************************************
***********************************************************************
* Copyright (c) 2002-2016, International Business Machines
* Corporation and others.  All Rights Reserved.
***********************************************************************
***********************************************************************
*/
/** 
 * This Program tests the performance of ICU's Normalization engine against Windows
 * to run it use the command like
 *
 * c:\normperf.exe -s C:\work\ICUCupertinoRep\icu4c\collation-perf-data  -i 10 -p 15 -f TestNames_Asian.txt -u -e UTF-8  -l
 */
#include "normperf.h"
#include "uoptions.h"
#include "cmemory.h" // for UPRV_LENGTHOF
#include <stdio.h>

UPerfFunction* NormalizerPerformanceTest::runIndexedTest(int32_t index, UBool exec,const char* &name, char* par) {
    switch (index) {
        TESTCASE(0,TestICU_NFC_NFD_Text);
        TESTCASE(1,TestICU_NFC_NFC_Text);
        TESTCASE(2,TestICU_NFC_Orig_Text);

        TESTCASE(3,TestICU_NFD_NFD_Text);
        TESTCASE(4,TestICU_NFD_NFC_Text);
        TESTCASE(5,TestICU_NFD_Orig_Text);

        TESTCASE(6,TestICU_FCD_NFD_Text);
        TESTCASE(7,TestICU_FCD_NFC_Text);
        TESTCASE(8,TestICU_FCD_Orig_Text);

        TESTCASE(9,TestWin_NFC_NFD_Text);
        TESTCASE(10,TestWin_NFC_NFC_Text);
        TESTCASE(11,TestWin_NFC_Orig_Text);

        TESTCASE(12,TestWin_NFD_NFD_Text);
        TESTCASE(13,TestWin_NFD_NFC_Text);
        TESTCASE(14,TestWin_NFD_Orig_Text);

        TESTCASE(15,TestQC_NFC_NFD_Text);
        TESTCASE(16,TestQC_NFC_NFC_Text);
        TESTCASE(17,TestQC_NFC_Orig_Text);

        TESTCASE(18,TestQC_NFD_NFD_Text);
        TESTCASE(19,TestQC_NFD_NFC_Text);
        TESTCASE(20,TestQC_NFD_Orig_Text);

        TESTCASE(21,TestQC_FCD_NFD_Text);
        TESTCASE(22,TestQC_FCD_NFC_Text);
        TESTCASE(23,TestQC_FCD_Orig_Text);

        TESTCASE(24,TestIsNormalized_NFC_NFD_Text);
        TESTCASE(25,TestIsNormalized_NFC_NFC_Text);
        TESTCASE(26,TestIsNormalized_NFC_Orig_Text);

        TESTCASE(27,TestIsNormalized_NFD_NFD_Text);
        TESTCASE(28,TestIsNormalized_NFD_NFC_Text);
        TESTCASE(29,TestIsNormalized_NFD_Orig_Text);

        TESTCASE(30,TestIsNormalized_FCD_NFD_Text);
        TESTCASE(31,TestIsNormalized_FCD_NFC_Text);
        TESTCASE(32,TestIsNormalized_FCD_Orig_Text);

        default: 
            name = ""; 
            return NULL;
    }
    return NULL;

}

void NormalizerPerformanceTest::normalizeInput(ULine* dest,const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options){
    int32_t reqLen = 0;
    UErrorCode status = U_ZERO_ERROR;
    for(;;){
        /* pure pre-flight */
        reqLen=unorm_normalize(src,srcLen,mode, options,NULL,0,&status);
        if(status==U_BUFFER_OVERFLOW_ERROR){
            status=U_ZERO_ERROR;
            dest->name = new UChar[reqLen+1];
            reqLen= unorm_normalize(src,srcLen,mode, options,dest->name,reqLen+1,&status);
            dest->len=reqLen;
            break;
        }else if(U_FAILURE(status)){
            printf("Could not normalize input. Error: %s", u_errorName(status));
        }
    }
}
UChar* NormalizerPerformanceTest::normalizeInput(int32_t& len, const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options){
    int32_t reqLen = 0;
    UErrorCode status = U_ZERO_ERROR;
    UChar* dest = NULL;
    for(;;){
        /* pure pre-flight */
        reqLen=unorm_normalize(src,srcLen,mode, options,NULL,0,&status);
        if(status==U_BUFFER_OVERFLOW_ERROR){
            status=U_ZERO_ERROR;
            dest = new UChar[reqLen+1];
            reqLen= unorm_normalize(src,srcLen,mode, options,dest,reqLen+1,&status);
            len=reqLen;
            break;
        }else if(U_FAILURE(status)){
            printf("Could not normalize input. Error: %s", u_errorName(status));
            return NULL;
        }
    }
    return dest;
}

static UOption cmdLineOptions[]={
    UOPTION_DEF("options", 'o', UOPT_OPTIONAL_ARG)
};

NormalizerPerformanceTest::NormalizerPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status)
: UPerfTest(argc,argv,status), options(0) {
    NFDBuffer = NULL;
    NFCBuffer = NULL;
    NFDBufferLen = 0;
    NFCBufferLen = 0;
    NFDFileLines = NULL;
    NFCFileLines = NULL;

    if(status== U_ILLEGAL_ARGUMENT_ERROR){
       fprintf(stderr,gUsageString, "normperf");
       return;
    }

    if(U_FAILURE(status)){
        fprintf(stderr, "FAILED to create UPerfTest object. Error: %s\n", u_errorName(status));
        return;
    }

    _remainingArgc = u_parseArgs(_remainingArgc, (char **)argv, UPRV_LENGTHOF(cmdLineOptions), cmdLineOptions);
    if(cmdLineOptions[0].doesOccur && cmdLineOptions[0].value!=NULL) {
        options=(int32_t)strtol(cmdLineOptions[0].value, NULL, 16);
    }

    if(line_mode){
        ULine* filelines = getLines(status);
        if(U_FAILURE(status)){
            fprintf(stderr, "FAILED to read lines from file and create UPerfTest object. Error: %s\n", u_errorName(status));
            return;
        }
        NFDFileLines = new ULine[numLines];
        NFCFileLines = new ULine[numLines];
    
        for(int32_t i=0;i<numLines;i++){
            normalizeInput(&NFDFileLines[i],filelines[i].name,filelines[i].len,UNORM_NFD, options);
            normalizeInput(&NFCFileLines[i],filelines[i].name,filelines[i].len,UNORM_NFC, options);

        }
    }else if(bulk_mode){
        int32_t srcLen = 0;
        const UChar* src = getBuffer(srcLen,status);
        NFDBufferLen = 0;
        NFCBufferLen = 0;

        if(U_FAILURE(status)){
            fprintf(stderr, "FAILED to read buffer from file and create UPerfTest object. Error: %s\n", u_errorName(status));
            return;
        }
         
        NFDBuffer = normalizeInput(NFDBufferLen,src,srcLen,UNORM_NFD, options);
        NFCBuffer = normalizeInput(NFCBufferLen,src,srcLen,UNORM_NFC, options);
    }
    
}

NormalizerPerformanceTest::~NormalizerPerformanceTest(){
    delete[] NFDFileLines;
    delete[] NFCFileLines;
    delete[] NFDBuffer;
    delete[] NFCBuffer;
}

// Test NFC Performance
UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_NFD_Text(){
    if(line_mode){
        NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFDFileLines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFDBuffer, NFDBufferLen, uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_NFC_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,NFCFileLines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFCBuffer, NFCBufferLen, uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_Orig_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,lines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,buffer, bufferLen, uselen);
        return func;
    }
}

// Test NFD Performance
UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_NFD_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFDFileLines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFDBuffer,NFDBufferLen, uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_NFC_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFCFileLines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFCBuffer,NFCBufferLen, uselen);
        return func; 
    }
}
UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_Orig_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,lines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,buffer,bufferLen, uselen);
        return func;
    }
}

// Test FCD Performance
UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_NFD_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFDFileLines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFDBuffer,NFDBufferLen, uselen);
        return func;        
    }

}
UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_NFC_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFCFileLines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFCBuffer,NFCBufferLen, uselen);
        return func;   
    }
}
UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_Orig_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,lines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,buffer,bufferLen, uselen);
        return func;   
    }
}

// Test Win NFC Performance
UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_NFD_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFDFileLines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFDBuffer,NFDBufferLen, uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_NFC_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFCFileLines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFCBuffer,NFCBufferLen, uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_Orig_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,lines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,buffer,bufferLen, uselen);
        return func;
    }
}

// Test Win NFD Performance
UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_NFD_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFDFileLines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFDBuffer,NFDBufferLen, uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_NFC_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFCFileLines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFCBuffer,NFCBufferLen, uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_Orig_Text(){
    if(line_mode){
        NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,lines,numLines, uselen);
        return func;
    }else{
        NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,buffer,bufferLen, uselen);
        return func;  
    }
}

// Test Quick Check Performance
UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_NFD_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_NFC, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_NFC, options,uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_NFC_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_NFC, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_NFC, options,uselen);
        return func; 
    }
}
UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_Orig_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_NFC, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_NFC, options,uselen);
        return func;
    }
}

UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_NFD_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_NFD, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_NFD, options,uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_NFC_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_NFD, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_NFD, options,uselen);
        return func; 
    }
}
UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_Orig_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_NFD, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_NFD, options,uselen);
        return func;
    }
}

UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_NFD_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_FCD, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_FCD, options,uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_NFC_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_FCD, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_FCD, options,uselen);
        return func; 
    }
}
UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_Orig_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_FCD, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_FCD, options,uselen);
        return func;
    }
}

// Test isNormalized Performance
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_NFD_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_NFC, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_NFC, options,uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_NFC_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_NFC, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_NFC, options,uselen);
        return func; 
    }
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_Orig_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_NFC, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_NFC, options,uselen);
        return func;
    }
}

UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_NFD_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_NFD, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_NFD, options,uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_NFC_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_NFD, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_NFD, options,uselen);
        return func; 
    }
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_Orig_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_NFD, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_NFD, options,uselen);
        return func;
    }
}

UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_NFD_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_FCD, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_FCD, options,uselen);
        return func;
    }
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_NFC_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_FCD, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_FCD, options,uselen);
        return func; 
    }
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_Orig_Text(){
    if(line_mode){
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_FCD, options,uselen);
        return func;
    }else{
        QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_FCD, options,uselen);
        return func;
    }
}

int main(int argc, const char* argv[]){
    UErrorCode status = U_ZERO_ERROR;
    NormalizerPerformanceTest test(argc, argv, status);
    if(U_FAILURE(status)){
        return status;
    }
    if(test.run()==FALSE){
        fprintf(stderr,"FAILED: Tests could not be run please check the arguments.\n");
        return -1;
    }
    return 0;
}
Commit	Line	Data
b75a7d8f	1	/*
f3c0d7a5 A	2	***********************************************************************
	3	* © 2016 and later: Unicode, Inc. and others.
	4	* License & terms of use: http://www.unicode.org/copyright.html#License
	5	***********************************************************************
	6	***********************************************************************
2ca993e8	7	* Copyright (c) 2002-2016, International Business Machines
b75a7d8f	8	* Corporation and others. All Rights Reserved.
f3c0d7a5 A	9	***********************************************************************
f3c0d7a5 A	10	***********************************************************************
b75a7d8f A	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"
73c04bcf	19	#include "uoptions.h"
b331163b	20	#include "cmemory.h" // for UPRV_LENGTHOF
73c04bcf	21	#include <stdio.h>
b75a7d8f	22
b75a7d8f A	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
2ca993e8	138	_remainingArgc = u_parseArgs(_remainingArgc, (char **)argv, UPRV_LENGTHOF(cmdLineOptions), cmdLineOptions);
b75a7d8f A	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	}