[apple/icu.git] / icuSources / test / perf / convperf / convperf.h

/*
**********************************************************************
* Copyright (c) 2002-2005, International Business Machines
* Corporation and others.  All Rights Reserved.
**********************************************************************
**********************************************************************
*/
#ifndef _CONVPERF_H
#define _CONVPERF_H

#include <mlang.h>
#include <objbase.h>
#include <stdlib.h>
#include "unicode/ucnv.h"
#include "unicode/uclean.h"
#include "unicode/ustring.h"

#include "unicode/uperf.h"

#define CONVERSION_FLAGS (0) /*WC_DEFAULTCHAR WC_COMPOSITECHECK & WC_SEPCHARS*/
#define MAX_BUF_SIZE  3048
#define LENGTHOF(array) (sizeof(array)/sizeof((array)[0]))

class ICUToUnicodePerfFunction : public UPerfFunction{
private:
    UConverter* conv;
    const char* src;
    int32_t srcLen;
    UChar* target;
    UChar* targetLimit;
    
public:
    ICUToUnicodePerfFunction(const char* name,  const char* source, int32_t sourceLen, UErrorCode& status){
        conv = ucnv_open(name,&status);
        src = source;
        srcLen = sourceLen;
        if(U_FAILURE(status)){
            conv = NULL;
            return;
        }
        target = NULL;
        targetLimit = NULL;
        int32_t reqdLen = ucnv_toUChars(conv,   target, 0,
                                        source, srcLen, &status);
        if(status==U_BUFFER_OVERFLOW_ERROR) {
            status=U_ZERO_ERROR;
            target=(UChar*)malloc((reqdLen) * U_SIZEOF_UCHAR*2);
            targetLimit = target + reqdLen;
            if(target == NULL){
                status = U_MEMORY_ALLOCATION_ERROR;
                return;
            }
        }
    }
    virtual void call(UErrorCode* status){
        const char* mySrc = src;
        const char* sourceLimit = src + srcLen;
        UChar* myTarget = target;
        ucnv_toUnicode(conv, &myTarget, targetLimit, &mySrc, sourceLimit, NULL, TRUE, status);
    }
    virtual long getOperationsPerIteration(void){
        return srcLen;
    }
    ~ICUToUnicodePerfFunction(){
        free(target);
        ucnv_close(conv);
    }
};
class ICUFromUnicodePerfFunction : public UPerfFunction{
private:
    UConverter* conv;
    const UChar* src;
    int32_t srcLen;
    char* target;
    char* targetLimit;
    const char* name;
    
public:
    ICUFromUnicodePerfFunction(const char* name,  const UChar* source, int32_t sourceLen, UErrorCode& status){
        conv = ucnv_open(name,&status);
        src = source;
        srcLen = sourceLen;
        if(U_FAILURE(status)){
            conv = NULL;
            return;
        }
        target = NULL;
        targetLimit = NULL;
        int32_t reqdLen = ucnv_fromUChars(conv,   target, 0,
                                          source, srcLen, &status);
        if(status==U_BUFFER_OVERFLOW_ERROR) {
            status=U_ZERO_ERROR;
            target=(char*)malloc((reqdLen*2));
            targetLimit = target + reqdLen;
            if(target == NULL){
                status = U_MEMORY_ALLOCATION_ERROR;
                return;
            }
        }
    }
    virtual void call(UErrorCode* status){
        const UChar* mySrc = src;
        const UChar* sourceLimit = src + srcLen;
        char* myTarget = target;
        ucnv_fromUnicode(conv,&myTarget, targetLimit, &mySrc, sourceLimit, NULL, TRUE, status);
    }
    virtual long getOperationsPerIteration(void){
        return srcLen;
    }
    ~ICUFromUnicodePerfFunction(){
        free(target);
        ucnv_close(conv);
    }
};

class ICUOpenAllConvertersFunction : public UPerfFunction{
private:
    UBool cleanup;
    int32_t availableConverters;
    const char **convNames;
public:
    ICUOpenAllConvertersFunction(UBool callCleanup, UErrorCode& status){
        int32_t idx;
        cleanup = callCleanup;
        availableConverters = ucnv_countAvailable();
        convNames = new const char *[availableConverters];
        for (idx = 0; idx < availableConverters; idx++) {
            convNames[idx] = ucnv_getAvailableName(idx);
        }
    }
    virtual void call(UErrorCode* status){
        int32_t idx;
        if (cleanup) {
            u_cleanup();
        }
        for (idx = 0; idx < availableConverters; idx++) {
            ucnv_close(ucnv_open(convNames[idx], status));
        }
    }
    virtual long getOperationsPerIteration(void){
        return availableConverters;
    }
    ~ICUOpenAllConvertersFunction(){
        delete []convNames;
    }
};

class WinANSIToUnicodePerfFunction : public UPerfFunction{

private:
    DWORD uiCodePage;
    char* src; 
    UINT  srcLen;
    WCHAR dest[MAX_BUF_SIZE];
    UINT  dstLen;
    const char* name;
public:
    WinANSIToUnicodePerfFunction(const char* cpName, char* pszIn,UINT szLen, UErrorCode& status){
        name = cpName;
        src = pszIn;
        srcLen = szLen;
        dstLen = LENGTHOF(dest);
        unsigned short bEnc[30]={'\0'};
        const char* tenc=name;
        for(int i=0;*tenc!='\0';i++){
            bEnc[i]=*tenc;
            tenc++;
        }
        LPMULTILANGUAGE2 pMulti;
        
        CoInitialize(NULL);

        /* create instance of converter object*/
        CoCreateInstance(
                          __uuidof(CMultiLanguage),
                          NULL,
                          CLSCTX_SERVER,
                          __uuidof(IMultiLanguage2),
                          (void**)&pMulti
                          );


        MIMECSETINFO mimeInfo;
        
        mimeInfo.uiCodePage = 0;
        mimeInfo.uiInternetEncoding =0;
        /* get the charset info */
        pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
        uiCodePage = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.uiInternetEncoding;
    }
    virtual void call(UErrorCode* status){
        int winSize =MultiByteToWideChar(uiCodePage,CONVERSION_FLAGS,src,srcLen,dest,dstLen);
    }
    virtual long getOperationsPerIteration(void){
        return srcLen;
    }
};

class WinANSIFromUnicodePerfFunction : public UPerfFunction{

private:
    DWORD uiCodePage;
    WCHAR* src; 
    UINT  srcLen;
    char dest[MAX_BUF_SIZE];
    UINT  dstLen;
    const char* name;
    BOOL lpUsedDefaultChar;

public:
    WinANSIFromUnicodePerfFunction(const char* cpName,  WCHAR* pszIn,UINT szLen, UErrorCode& status){
        name = cpName;
        src = pszIn;
        srcLen = szLen;
        dstLen = LENGTHOF(dest);
        lpUsedDefaultChar=FALSE;
        unsigned short bEnc[30]={'\0'};
        const char* tenc=name;
        for(int i=0;*tenc!='\0';i++){
            bEnc[i]=*tenc;
            tenc++;
        }
        LPMULTILANGUAGE2 pMulti;
        
        CoInitialize(NULL);

        /* create instance of converter object*/
        CoCreateInstance(
                          __uuidof(CMultiLanguage),
                          NULL,
                          CLSCTX_SERVER,
                          __uuidof(IMultiLanguage2),
                          (void**)&pMulti
                          );


        MIMECSETINFO mimeInfo;
        mimeInfo.uiCodePage = 0;
        mimeInfo.uiInternetEncoding =0;
        /* get the charset info */
        pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
        uiCodePage = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.uiInternetEncoding;
    }
    virtual void call(UErrorCode* status){
        BOOL* pUsedDefaultChar =(uiCodePage==CP_UTF8)?NULL:&lpUsedDefaultChar;
        int winSize = WideCharToMultiByte(uiCodePage,CONVERSION_FLAGS,src,srcLen,dest,dstLen,NULL, pUsedDefaultChar);
    }
    virtual long getOperationsPerIteration(void){
        return srcLen;
    }
};
static inline void getErr(HRESULT err, UErrorCode& status){

    switch (err){

    case S_OK:
        //printf("Operation %s successful\n",operation);
        break;
    case S_FALSE:
        status = U_INTERNAL_PROGRAM_ERROR;
        break;
    case E_FAIL:
        status = U_ILLEGAL_CHAR_FOUND;
    }
}
class WinIMultiLanguageToUnicodePerfFunction : public UPerfFunction{

private:
    LPMULTILANGUAGE2 pMulti;
    LPMLANGCONVERTCHARSET pConvToUni;
    char* src; 
    UINT  srcLen;
    WCHAR dst[MAX_BUF_SIZE];
    UINT  dstLen;
    const char* cpName;

public:
    WinIMultiLanguageToUnicodePerfFunction(const char* name,char* source, UINT sourceLen, UErrorCode& status){
             
        CoInitialize(NULL);

        /* create instance of converter object*/
        CoCreateInstance(
                          __uuidof(CMultiLanguage),
                          NULL,
                          CLSCTX_SERVER,
                          __uuidof(IMultiLanguage2),
                          (void**)&pMulti
                          );


        MIMECSETINFO mimeInfo;
        mimeInfo.uiCodePage = 0;
        mimeInfo.uiInternetEncoding =0;
        HRESULT err=S_OK;
        unsigned short bEnc[30]={'\0'};
        const char* tenc=name;
        for(int i=0;*tenc!='\0';i++){
            bEnc[i]=*tenc;
            tenc++;
        }
        /* get the charset info */
        pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
        pMulti->CreateConvertCharset(mimeInfo.uiCodePage, 1200 /*unicode*/, (DWORD)0,&pConvToUni);
        getErr(err,status);
        src = source;
        srcLen = sourceLen;
        dstLen = LENGTHOF(dst);
        cpName = name;
    }

    virtual void call(UErrorCode* status){
        HRESULT err= pConvToUni->DoConversionToUnicode(src,&srcLen,dst, &dstLen);
        getErr(err,*status);
    }
    virtual long getOperationsPerIteration(void){
        return srcLen;
    }
};

class WinIMultiLanguageFromUnicodePerfFunction : public UPerfFunction{

private:
    LPMULTILANGUAGE2 pMulti;
    LPMLANGCONVERTCHARSET pConvFromUni;
    WCHAR* src; 
    UINT  srcLen;
    char dst[MAX_BUF_SIZE];
    UINT  dstLen;
    const char* cpName;

public:
    WinIMultiLanguageFromUnicodePerfFunction(const char* name,WCHAR* source, UINT sourceLen, UErrorCode& status){
             
        CoInitialize(NULL);

        /* create instance of converter object*/
        CoCreateInstance(
                          __uuidof(CMultiLanguage),
                          NULL,
                          CLSCTX_SERVER,
                          __uuidof(IMultiLanguage2),
                          (void**)&pMulti
                          );


        MIMECSETINFO mimeInfo;
        mimeInfo.uiCodePage = 0;
        mimeInfo.uiInternetEncoding =0;
        HRESULT err=S_OK;
        unsigned short bEnc[30]={'\0'};
        const char* tenc=name;
        for(int i=0;*tenc!='\0';i++){
            bEnc[i]=*tenc;
            tenc++;
        }
        /* get the charset info */
        pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
        pMulti->CreateConvertCharset(1200 /*unicode*/, mimeInfo.uiCodePage, (DWORD)0,&pConvFromUni);
        getErr(err,status);
        src = source;
        srcLen = sourceLen;
        dstLen = LENGTHOF(dst);
        cpName = name;

    }

    virtual void call(UErrorCode* status){
        HRESULT err= pConvFromUni->DoConversionFromUnicode(src,&srcLen,dst, &dstLen);
        getErr(err,*status);
    }
    virtual long getOperationsPerIteration(void){
        return srcLen;
    }
};

class WinIMultiLanguage2ToUnicodePerfFunction : public UPerfFunction{

private:
    LPMULTILANGUAGE2 pMulti;
    char* src; 
    UINT  srcLen;
    WCHAR dst[MAX_BUF_SIZE];
    UINT  dstLen;
    const char* cpName;
    DWORD dwEnc;
public:
    WinIMultiLanguage2ToUnicodePerfFunction(const char* name,char* source, UINT sourceLen, UErrorCode& status){
             
        CoInitialize(NULL);

        /* create instance of converter object*/
        CoCreateInstance(
                          __uuidof(CMultiLanguage),
                          NULL,
                          CLSCTX_SERVER,
                          __uuidof(IMultiLanguage2),
                          (void**)&pMulti
                          );

        src = source;
        srcLen = sourceLen;
        dstLen = LENGTHOF(dst);
        cpName = name;
        unsigned short bEnc[30]={'\0'};
        const char* tenc=name;
        for(int i=0;*tenc!='\0';i++){
            bEnc[i]=*tenc;
            tenc++;
        }
        /* get the charset info */
        MIMECSETINFO mimeInfo;
        mimeInfo.uiCodePage = 0;
        mimeInfo.uiInternetEncoding =0;
        pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
        dwEnc = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.uiInternetEncoding;
    }

    virtual void call(UErrorCode* status){
        DWORD dwMode=0;
        HRESULT err=  pMulti->ConvertStringToUnicode(&dwMode,dwEnc,(char*)src,&srcLen,dst, &dstLen);
        getErr(err,*status);
    }
    virtual long getOperationsPerIteration(void){
        return srcLen;
    }
};

class WinIMultiLanguage2FromUnicodePerfFunction : public UPerfFunction{

private:
    LPMULTILANGUAGE2 pMulti;
    LPMLANGCONVERTCHARSET pConvFromUni;
    WCHAR* src; 
    UINT  srcLen;
    char dst[MAX_BUF_SIZE];
    UINT  dstLen;
    const char* cpName;
    DWORD dwEnc;

public:
    WinIMultiLanguage2FromUnicodePerfFunction(const char* name,WCHAR* source, UINT sourceLen, UErrorCode& status){
             
        CoInitialize(NULL);

        /* create instance of converter object*/
        CoCreateInstance(
                          __uuidof(CMultiLanguage),
                          NULL,
                          CLSCTX_SERVER,
                          __uuidof(IMultiLanguage2),
                          (void**)&pMulti
                          );


        unsigned short bEnc[30]={'\0'};
        const char* tenc=name;
        for(int i=0;*tenc!='\0';i++){
            bEnc[i]=*tenc;
            tenc++;
        }
        src = source;
        srcLen = sourceLen;
        dstLen = LENGTHOF(dst);
        cpName = name;
        /* get the charset info */
        MIMECSETINFO mimeInfo;
        mimeInfo.uiCodePage = 0;
        mimeInfo.uiInternetEncoding =0;

        pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
        dwEnc = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.uiInternetEncoding;
    }

    virtual void call(UErrorCode* status){
        DWORD dwMode=0;
        HRESULT err= pMulti->ConvertStringFromUnicode(&dwMode,dwEnc,src,&srcLen,dst, &dstLen);
        getErr(err,*status);
    }
    virtual long getOperationsPerIteration(void){
        return srcLen;
    }
};

class  ConverterPerformanceTest : public UPerfTest{

public:

    ConverterPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status);
    ~ConverterPerformanceTest();
    virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const char* &name, char* par = NULL);    
    
    UPerfFunction* TestICU_CleanOpenAllConverters();
    UPerfFunction* TestICU_OpenAllConverters();

    UPerfFunction* TestICU_UTF8_ToUnicode();
    UPerfFunction* TestICU_UTF8_FromUnicode();
    UPerfFunction* TestWinANSI_UTF8_ToUnicode();
    UPerfFunction* TestWinANSI_UTF8_FromUnicode();
    UPerfFunction* TestWinIML2_UTF8_ToUnicode();
    UPerfFunction* TestWinIML2_UTF8_FromUnicode();
        
    UPerfFunction* TestICU_Latin1_ToUnicode();
    UPerfFunction* TestICU_Latin1_FromUnicode();
    UPerfFunction* TestWinANSI_Latin1_ToUnicode();
    UPerfFunction* TestWinANSI_Latin1_FromUnicode();
    UPerfFunction* TestWinIML2_Latin1_ToUnicode();
    UPerfFunction* TestWinIML2_Latin1_FromUnicode();

    UPerfFunction* TestICU_EBCDIC_Arabic_ToUnicode();
    UPerfFunction* TestICU_EBCDIC_Arabic_FromUnicode();
    UPerfFunction* TestWinANSI_EBCDIC_Arabic_ToUnicode();
    UPerfFunction* TestWinANSI_EBCDIC_Arabic_FromUnicode();
    UPerfFunction* TestWinIML2_EBCDIC_Arabic_ToUnicode();
    UPerfFunction* TestWinIML2_EBCDIC_Arabic_FromUnicode();

    UPerfFunction* TestICU_Latin8_ToUnicode();
    UPerfFunction* TestICU_Latin8_FromUnicode();
    UPerfFunction* TestWinANSI_Latin8_ToUnicode();
    UPerfFunction* TestWinANSI_Latin8_FromUnicode();
    UPerfFunction* TestWinIML2_Latin8_ToUnicode();
    UPerfFunction* TestWinIML2_Latin8_FromUnicode();

    
    UPerfFunction* TestICU_SJIS_ToUnicode();
    UPerfFunction* TestICU_SJIS_FromUnicode();
    UPerfFunction* TestWinANSI_SJIS_ToUnicode();
    UPerfFunction* TestWinANSI_SJIS_FromUnicode();
    UPerfFunction* TestWinIML2_SJIS_ToUnicode();
    UPerfFunction* TestWinIML2_SJIS_FromUnicode();

    UPerfFunction* TestICU_EUCJP_ToUnicode();
    UPerfFunction* TestICU_EUCJP_FromUnicode();
    UPerfFunction* TestWinANSI_EUCJP_ToUnicode();
    UPerfFunction* TestWinANSI_EUCJP_FromUnicode();
    UPerfFunction* TestWinIML2_EUCJP_ToUnicode();
    UPerfFunction* TestWinIML2_EUCJP_FromUnicode();

    UPerfFunction* TestICU_GB2312_ToUnicode();
    UPerfFunction* TestICU_GB2312_FromUnicode();
    UPerfFunction* TestWinANSI_GB2312_ToUnicode();
    UPerfFunction* TestWinANSI_GB2312_FromUnicode();
    UPerfFunction* TestWinIML2_GB2312_ToUnicode();
    UPerfFunction* TestWinIML2_GB2312_FromUnicode();


    UPerfFunction* TestICU_ISO2022KR_ToUnicode();
    UPerfFunction* TestICU_ISO2022KR_FromUnicode();
    UPerfFunction* TestWinANSI_ISO2022KR_ToUnicode();
    UPerfFunction* TestWinANSI_ISO2022KR_FromUnicode();
    UPerfFunction* TestWinIML2_ISO2022KR_ToUnicode();
    UPerfFunction* TestWinIML2_ISO2022KR_FromUnicode();   

    UPerfFunction* TestICU_ISO2022JP_ToUnicode();
    UPerfFunction* TestICU_ISO2022JP_FromUnicode();
    UPerfFunction* TestWinANSI_ISO2022JP_ToUnicode();
    UPerfFunction* TestWinANSI_ISO2022JP_FromUnicode();
    UPerfFunction* TestWinIML2_ISO2022JP_ToUnicode();
    UPerfFunction* TestWinIML2_ISO2022JP_FromUnicode(); 

};

#endif
Commit	Line	Data
374ca955 A	1	/*
374ca955 A	2	**********************************************************************
73c04bcf	3	* Copyright (c) 2002-2005, International Business Machines
374ca955 A	4	* Corporation and others. All Rights Reserved.
	5	**********************************************************************
	6	**********************************************************************
	7	*/
	8	#ifndef _CONVPERF_H
	9	#define _CONVPERF_H
	10
73c04bcf A	11	#include <mlang.h>
	12	#include <objbase.h>
	13	#include <stdlib.h>
374ca955 A	14	#include "unicode/ucnv.h"
	15	#include "unicode/uclean.h"
	16	#include "unicode/ustring.h"
73c04bcf A	17
73c04bcf A	18	#include "unicode/uperf.h"
374ca955 A	19
	20	#define CONVERSION_FLAGS (0) /WC_DEFAULTCHAR WC_COMPOSITECHECK & WC_SEPCHARS/
	21	#define MAX_BUF_SIZE 3048
	22	#define LENGTHOF(array) (sizeof(array)/sizeof((array)[0]))
	23
	24	class ICUToUnicodePerfFunction : public UPerfFunction{
	25	private:
	26	UConverter* conv;
	27	const char* src;
	28	int32_t srcLen;
	29	UChar* target;
	30	UChar* targetLimit;
	31
	32	public:
	33	ICUToUnicodePerfFunction(const char* name, const char* source, int32_t sourceLen, UErrorCode& status){
	34	conv = ucnv_open(name,&status);
	35	src = source;
	36	srcLen = sourceLen;
	37	if(U_FAILURE(status)){
	38	conv = NULL;
	39	return;
	40	}
	41	target = NULL;
	42	targetLimit = NULL;
	43	int32_t reqdLen = ucnv_toUChars(conv, target, 0,
	44	source, srcLen, &status);
	45	if(status==U_BUFFER_OVERFLOW_ERROR) {
	46	status=U_ZERO_ERROR;
73c04bcf	47	target=(UChar)malloc((reqdLen) U_SIZEOF_UCHAR*2);
374ca955 A	48	targetLimit = target + reqdLen;
	49	if(target == NULL){
	50	status = U_MEMORY_ALLOCATION_ERROR;
	51	return;
	52	}
	53	}
	54	}
	55	virtual void call(UErrorCode* status){
	56	const char* mySrc = src;
	57	const char* sourceLimit = src + srcLen;
	58	UChar* myTarget = target;
	59	ucnv_toUnicode(conv, &myTarget, targetLimit, &mySrc, sourceLimit, NULL, TRUE, status);
	60	}
	61	virtual long getOperationsPerIteration(void){
	62	return srcLen;
	63	}
	64	~ICUToUnicodePerfFunction(){
73c04bcf	65	free(target);
374ca955 A	66	ucnv_close(conv);
	67	}
	68	};
	69	class ICUFromUnicodePerfFunction : public UPerfFunction{
	70	private:
	71	UConverter* conv;
	72	const UChar* src;
	73	int32_t srcLen;
	74	char* target;
	75	char* targetLimit;
	76	const char* name;
	77
	78	public:
	79	ICUFromUnicodePerfFunction(const char* name, const UChar* source, int32_t sourceLen, UErrorCode& status){
	80	conv = ucnv_open(name,&status);
	81	src = source;
	82	srcLen = sourceLen;
	83	if(U_FAILURE(status)){
	84	conv = NULL;
	85	return;
	86	}
	87	target = NULL;
	88	targetLimit = NULL;
	89	int32_t reqdLen = ucnv_fromUChars(conv, target, 0,
	90	source, srcLen, &status);
	91	if(status==U_BUFFER_OVERFLOW_ERROR) {
	92	status=U_ZERO_ERROR;
73c04bcf	93	target=(char)malloc((reqdLen2));
374ca955 A	94	targetLimit = target + reqdLen;
	95	if(target == NULL){
	96	status = U_MEMORY_ALLOCATION_ERROR;
	97	return;
	98	}
	99	}
	100	}
	101	virtual void call(UErrorCode* status){
	102	const UChar* mySrc = src;
	103	const UChar* sourceLimit = src + srcLen;
	104	char* myTarget = target;
	105	ucnv_fromUnicode(conv,&myTarget, targetLimit, &mySrc, sourceLimit, NULL, TRUE, status);
	106	}
	107	virtual long getOperationsPerIteration(void){
	108	return srcLen;
	109	}
	110	~ICUFromUnicodePerfFunction(){
73c04bcf	111	free(target);
374ca955 A	112	ucnv_close(conv);
	113	}
	114	};
	115
	116	class ICUOpenAllConvertersFunction : public UPerfFunction{
	117	private:
	118	UBool cleanup;
	119	int32_t availableConverters;
	120	const char **convNames;
	121	public:
	122	ICUOpenAllConvertersFunction(UBool callCleanup, UErrorCode& status){
	123	int32_t idx;
	124	cleanup = callCleanup;
	125	availableConverters = ucnv_countAvailable();
	126	convNames = new const char *[availableConverters];
	127	for (idx = 0; idx < availableConverters; idx++) {
	128	convNames[idx] = ucnv_getAvailableName(idx);
	129	}
	130	}
	131	virtual void call(UErrorCode* status){
	132	int32_t idx;
	133	if (cleanup) {
	134	u_cleanup();
	135	}
	136	for (idx = 0; idx < availableConverters; idx++) {
	137	ucnv_close(ucnv_open(convNames[idx], status));
	138	}
	139	}
	140	virtual long getOperationsPerIteration(void){
	141	return availableConverters;
	142	}
	143	~ICUOpenAllConvertersFunction(){
	144	delete []convNames;
	145	}
	146	};
	147
	148	class WinANSIToUnicodePerfFunction : public UPerfFunction{
	149
	150	private:
	151	DWORD uiCodePage;
	152	char* src;
	153	UINT srcLen;
	154	WCHAR dest[MAX_BUF_SIZE];
	155	UINT dstLen;
	156	const char* name;
	157	public:
	158	WinANSIToUnicodePerfFunction(const char* cpName, char* pszIn,UINT szLen, UErrorCode& status){
	159	name = cpName;
	160	src = pszIn;
	161	srcLen = szLen;
	162	dstLen = LENGTHOF(dest);
	163	unsigned short bEnc[30]={'\0'};
	164	const char* tenc=name;
	165	for(int i=0;*tenc!='\0';i++){
	166	bEnc[i]=*tenc;
	167	tenc++;
	168	}
	169	LPMULTILANGUAGE2 pMulti;
	170
	171	CoInitialize(NULL);
	172
	173	/* create instance of converter object*/
	174	CoCreateInstance(
	175	__uuidof(CMultiLanguage),
176	NULL,
177	CLSCTX_SERVER,
178	__uuidof(IMultiLanguage2),
179	(void**)&pMulti
180	);
181
182
183
184	MIMECSETINFO mimeInfo;
185
186	mimeInfo.uiCodePage = 0;
187	mimeInfo.uiInternetEncoding =0;
188	/* get the charset info */
46f4442e	189	pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
374ca955 A	190	uiCodePage = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.uiInternetEncoding;
	191	}
	192	virtual void call(UErrorCode* status){
	193	int winSize =MultiByteToWideChar(uiCodePage,CONVERSION_FLAGS,src,srcLen,dest,dstLen);
	194	}
	195	virtual long getOperationsPerIteration(void){
	196	return srcLen;
	197	}
	198	};
	199
	200	class WinANSIFromUnicodePerfFunction : public UPerfFunction{
	201
	202	private:
	203	DWORD uiCodePage;
	204	WCHAR* src;
	205	UINT srcLen;
	206	char dest[MAX_BUF_SIZE];
	207	UINT dstLen;
	208	const char* name;
	209	BOOL lpUsedDefaultChar;
	210
	211	public:
	212	WinANSIFromUnicodePerfFunction(const char* cpName, WCHAR* pszIn,UINT szLen, UErrorCode& status){
	213	name = cpName;
	214	src = pszIn;
	215	srcLen = szLen;
	216	dstLen = LENGTHOF(dest);
	217	lpUsedDefaultChar=FALSE;
	218	unsigned short bEnc[30]={'\0'};
	219	const char* tenc=name;
	220	for(int i=0;*tenc!='\0';i++){
	221	bEnc[i]=*tenc;
	222	tenc++;
	223	}
	224	LPMULTILANGUAGE2 pMulti;
	225
	226	CoInitialize(NULL);
	227
	228	/* create instance of converter object*/
	229	CoCreateInstance(
	230	__uuidof(CMultiLanguage),
	231	NULL,
	232	CLSCTX_SERVER,
	233	__uuidof(IMultiLanguage2),
	234	(void**)&pMulti
	235	);
	236
	237
	238
	239	MIMECSETINFO mimeInfo;
	240	mimeInfo.uiCodePage = 0;
	241	mimeInfo.uiInternetEncoding =0;
	242	/* get the charset info */
46f4442e	243	pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
374ca955 A	244	uiCodePage = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.uiInternetEncoding;
	245	}
	246	virtual void call(UErrorCode* status){
	247	BOOL* pUsedDefaultChar =(uiCodePage==CP_UTF8)?NULL:&lpUsedDefaultChar;
	248	int winSize = WideCharToMultiByte(uiCodePage,CONVERSION_FLAGS,src,srcLen,dest,dstLen,NULL, pUsedDefaultChar);
	249	}
	250	virtual long getOperationsPerIteration(void){
	251	return srcLen;
	252	}
	253	};
	254	static inline void getErr(HRESULT err, UErrorCode& status){
	255
	256	switch (err){
	257
	258	case S_OK:
	259	//printf("Operation %s successful\n",operation);
	260	break;
	261	case S_FALSE:
	262	status = U_INTERNAL_PROGRAM_ERROR;
	263	break;
	264	case E_FAIL:
	265	status = U_ILLEGAL_CHAR_FOUND;
	266	}
	267	}
	268	class WinIMultiLanguageToUnicodePerfFunction : public UPerfFunction{
	269
	270	private:
	271	LPMULTILANGUAGE2 pMulti;
	272	LPMLANGCONVERTCHARSET pConvToUni;
	273	char* src;
	274	UINT srcLen;
	275	WCHAR dst[MAX_BUF_SIZE];
	276	UINT dstLen;
	277	const char* cpName;
	278
	279	public:
	280	WinIMultiLanguageToUnicodePerfFunction(const char* name,char* source, UINT sourceLen, UErrorCode& status){
	281
	282	CoInitialize(NULL);
	283
	284	/* create instance of converter object*/
	285	CoCreateInstance(
	286	__uuidof(CMultiLanguage),
	287	NULL,
	288	CLSCTX_SERVER,
	289	__uuidof(IMultiLanguage2),
	290	(void**)&pMulti
	291	);
	292
	293
	294
	295	MIMECSETINFO mimeInfo;
	296	mimeInfo.uiCodePage = 0;
	297	mimeInfo.uiInternetEncoding =0;
	298	HRESULT err=S_OK;
	299	unsigned short bEnc[30]={'\0'};
	300	const char* tenc=name;
	301	for(int i=0;*tenc!='\0';i++){
	302	bEnc[i]=*tenc;
	303	tenc++;
	304	}
	305	/* get the charset info */
46f4442e	306	pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
374ca955 A	307	pMulti->CreateConvertCharset(mimeInfo.uiCodePage, 1200 /unicode/, (DWORD)0,&pConvToUni);
	308	getErr(err,status);
	309	src = source;
	310	srcLen = sourceLen;
	311	dstLen = LENGTHOF(dst);
	312	cpName = name;
	313	}
	314
	315	virtual void call(UErrorCode* status){
	316	HRESULT err= pConvToUni->DoConversionToUnicode(src,&srcLen,dst, &dstLen);
	317	getErr(err,*status);
	318	}
	319	virtual long getOperationsPerIteration(void){
	320	return srcLen;
	321	}
	322	};
	323
	324	class WinIMultiLanguageFromUnicodePerfFunction : public UPerfFunction{
	325
	326	private:
	327	LPMULTILANGUAGE2 pMulti;
	328	LPMLANGCONVERTCHARSET pConvFromUni;
	329	WCHAR* src;
	330	UINT srcLen;
	331	char dst[MAX_BUF_SIZE];
	332	UINT dstLen;
	333	const char* cpName;
	334
	335	public:
	336	WinIMultiLanguageFromUnicodePerfFunction(const char* name,WCHAR* source, UINT sourceLen, UErrorCode& status){
	337
	338	CoInitialize(NULL);
	339
	340	/* create instance of converter object*/
	341	CoCreateInstance(
	342	__uuidof(CMultiLanguage),
	343	NULL,
	344	CLSCTX_SERVER,
	345	__uuidof(IMultiLanguage2),
	346	(void**)&pMulti
	347	);
	348
	349
	350
	351	MIMECSETINFO mimeInfo;
	352	mimeInfo.uiCodePage = 0;
	353	mimeInfo.uiInternetEncoding =0;
	354	HRESULT err=S_OK;
	355	unsigned short bEnc[30]={'\0'};
	356	const char* tenc=name;
	357	for(int i=0;*tenc!='\0';i++){
	358	bEnc[i]=*tenc;
	359	tenc++;
	360	}
	361	/* get the charset info */
46f4442e	362	pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
374ca955 A	363	pMulti->CreateConvertCharset(1200 /unicode/, mimeInfo.uiCodePage, (DWORD)0,&pConvFromUni);
	364	getErr(err,status);
	365	src = source;
	366	srcLen = sourceLen;
	367	dstLen = LENGTHOF(dst);
	368	cpName = name;
	369
	370	}
	371
	372	virtual void call(UErrorCode* status){
	373	HRESULT err= pConvFromUni->DoConversionFromUnicode(src,&srcLen,dst, &dstLen);
	374	getErr(err,*status);
	375	}
	376	virtual long getOperationsPerIteration(void){
	377	return srcLen;
	378	}
	379	};
	380
	381	class WinIMultiLanguage2ToUnicodePerfFunction : public UPerfFunction{
	382
	383	private:
	384	LPMULTILANGUAGE2 pMulti;
	385	char* src;
	386	UINT srcLen;
	387	WCHAR dst[MAX_BUF_SIZE];
	388	UINT dstLen;
	389	const char* cpName;
	390	DWORD dwEnc;
	391	public:
	392	WinIMultiLanguage2ToUnicodePerfFunction(const char* name,char* source, UINT sourceLen, UErrorCode& status){
	393
	394	CoInitialize(NULL);
	395
	396	/* create instance of converter object*/
	397	CoCreateInstance(
	398	__uuidof(CMultiLanguage),
	399	NULL,
	400	CLSCTX_SERVER,
	401	__uuidof(IMultiLanguage2),
	402	(void**)&pMulti
	403	);
	404
	405	src = source;
	406	srcLen = sourceLen;
	407	dstLen = LENGTHOF(dst);
	408	cpName = name;
	409	unsigned short bEnc[30]={'\0'};
	410	const char* tenc=name;
	411	for(int i=0;*tenc!='\0';i++){
	412	bEnc[i]=*tenc;
	413	tenc++;
	414	}
	415	/* get the charset info */
	416	MIMECSETINFO mimeInfo;
	417	mimeInfo.uiCodePage = 0;
	418	mimeInfo.uiInternetEncoding =0;
46f4442e	419	pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
374ca955 A	420	dwEnc = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.uiInternetEncoding;
	421	}
	422
	423	virtual void call(UErrorCode* status){
	424	DWORD dwMode=0;
	425	HRESULT err= pMulti->ConvertStringToUnicode(&dwMode,dwEnc,(char*)src,&srcLen,dst, &dstLen);
	426	getErr(err,*status);
	427	}
	428	virtual long getOperationsPerIteration(void){
	429	return srcLen;
	430	}
	431	};
	432
	433	class WinIMultiLanguage2FromUnicodePerfFunction : public UPerfFunction{
	434
	435	private:
	436	LPMULTILANGUAGE2 pMulti;
	437	LPMLANGCONVERTCHARSET pConvFromUni;
	438	WCHAR* src;
	439	UINT srcLen;
	440	char dst[MAX_BUF_SIZE];
	441	UINT dstLen;
	442	const char* cpName;
	443	DWORD dwEnc;
	444
	445	public:
	446	WinIMultiLanguage2FromUnicodePerfFunction(const char* name,WCHAR* source, UINT sourceLen, UErrorCode& status){
	447
	448	CoInitialize(NULL);
	449
	450	/* create instance of converter object*/
	451	CoCreateInstance(
	452	__uuidof(CMultiLanguage),
	453	NULL,
	454	CLSCTX_SERVER,
	455	__uuidof(IMultiLanguage2),
	456	(void**)&pMulti
	457	);
	458
	459
	460	unsigned short bEnc[30]={'\0'};
	461	const char* tenc=name;
	462	for(int i=0;*tenc!='\0';i++){
	463	bEnc[i]=*tenc;
	464	tenc++;
	465	}
	466	src = source;
	467	srcLen = sourceLen;
	468	dstLen = LENGTHOF(dst);
	469	cpName = name;
	470	/* get the charset info */
	471	MIMECSETINFO mimeInfo;
	472	mimeInfo.uiCodePage = 0;
	473	mimeInfo.uiInternetEncoding =0;
	474
46f4442e	475	pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
374ca955 A	476	dwEnc = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.uiInternetEncoding;
	477	}
	478
	479	virtual void call(UErrorCode* status){
	480	DWORD dwMode=0;
	481	HRESULT err= pMulti->ConvertStringFromUnicode(&dwMode,dwEnc,src,&srcLen,dst, &dstLen);
	482	getErr(err,*status);
	483	}
	484	virtual long getOperationsPerIteration(void){
	485	return srcLen;
	486	}
	487	};
	488
	489	class ConverterPerformanceTest : public UPerfTest{
	490
	491	public:
	492
	493	ConverterPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status);
	494	~ConverterPerformanceTest();
	495	virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const char* &name, char* par = NULL);
	496
	497	UPerfFunction* TestICU_CleanOpenAllConverters();
	498	UPerfFunction* TestICU_OpenAllConverters();
	499
	500	UPerfFunction* TestICU_UTF8_ToUnicode();
	501	UPerfFunction* TestICU_UTF8_FromUnicode();
	502	UPerfFunction* TestWinANSI_UTF8_ToUnicode();
	503	UPerfFunction* TestWinANSI_UTF8_FromUnicode();
	504	UPerfFunction* TestWinIML2_UTF8_ToUnicode();
	505	UPerfFunction* TestWinIML2_UTF8_FromUnicode();
	506
	507	UPerfFunction* TestICU_Latin1_ToUnicode();
	508	UPerfFunction* TestICU_Latin1_FromUnicode();
	509	UPerfFunction* TestWinANSI_Latin1_ToUnicode();
	510	UPerfFunction* TestWinANSI_Latin1_FromUnicode();
	511	UPerfFunction* TestWinIML2_Latin1_ToUnicode();
	512	UPerfFunction* TestWinIML2_Latin1_FromUnicode();
	513
	514	UPerfFunction* TestICU_EBCDIC_Arabic_ToUnicode();
	515	UPerfFunction* TestICU_EBCDIC_Arabic_FromUnicode();
	516	UPerfFunction* TestWinANSI_EBCDIC_Arabic_ToUnicode();
	517	UPerfFunction* TestWinANSI_EBCDIC_Arabic_FromUnicode();
	518	UPerfFunction* TestWinIML2_EBCDIC_Arabic_ToUnicode();
	519	UPerfFunction* TestWinIML2_EBCDIC_Arabic_FromUnicode();
	520
	521	UPerfFunction* TestICU_Latin8_ToUnicode();
	522	UPerfFunction* TestICU_Latin8_FromUnicode();
	523	UPerfFunction* TestWinANSI_Latin8_ToUnicode();
	524	UPerfFunction* TestWinANSI_Latin8_FromUnicode();
	525	UPerfFunction* TestWinIML2_Latin8_ToUnicode();
	526	UPerfFunction* TestWinIML2_Latin8_FromUnicode();
	527
	528
	529	UPerfFunction* TestICU_SJIS_ToUnicode();
	530	UPerfFunction* TestICU_SJIS_FromUnicode();
	531	UPerfFunction* TestWinANSI_SJIS_ToUnicode();
	532	UPerfFunction* TestWinANSI_SJIS_FromUnicode();
	533	UPerfFunction* TestWinIML2_SJIS_ToUnicode();
	534	UPerfFunction* TestWinIML2_SJIS_FromUnicode();
	535
	536	UPerfFunction* TestICU_EUCJP_ToUnicode();
	537	UPerfFunction* TestICU_EUCJP_FromUnicode();
	538	UPerfFunction* TestWinANSI_EUCJP_ToUnicode();
	539	UPerfFunction* TestWinANSI_EUCJP_FromUnicode();
540	UPerfFunction* TestWinIML2_EUCJP_ToUnicode();
541	UPerfFunction* TestWinIML2_EUCJP_FromUnicode();
542
543	UPerfFunction* TestICU_GB2312_ToUnicode();
544	UPerfFunction* TestICU_GB2312_FromUnicode();
545	UPerfFunction* TestWinANSI_GB2312_ToUnicode();
546	UPerfFunction* TestWinANSI_GB2312_FromUnicode();
547	UPerfFunction* TestWinIML2_GB2312_ToUnicode();
548	UPerfFunction* TestWinIML2_GB2312_FromUnicode();
549
550
551	UPerfFunction* TestICU_ISO2022KR_ToUnicode();
552	UPerfFunction* TestICU_ISO2022KR_FromUnicode();
553	UPerfFunction* TestWinANSI_ISO2022KR_ToUnicode();
554	UPerfFunction* TestWinANSI_ISO2022KR_FromUnicode();
555	UPerfFunction* TestWinIML2_ISO2022KR_ToUnicode();
556	UPerfFunction* TestWinIML2_ISO2022KR_FromUnicode();
557
558	UPerfFunction* TestICU_ISO2022JP_ToUnicode();
559	UPerfFunction* TestICU_ISO2022JP_FromUnicode();
560	UPerfFunction* TestWinANSI_ISO2022JP_ToUnicode();
561	UPerfFunction* TestWinANSI_ISO2022JP_FromUnicode();
562	UPerfFunction* TestWinIML2_ISO2022JP_ToUnicode();
563	UPerfFunction* TestWinIML2_ISO2022JP_FromUnicode();
564
565	};
566
567	#endif
568