--- /dev/null
+/*
+**********************************************************************
+* Copyright (c) 2002-2004, International Business Machines
+* Corporation and others. All Rights Reserved.
+**********************************************************************
+**********************************************************************
+*/
+#ifndef _CONVPERF_H
+#define _CONVPERF_H
+
+#include "uperf.h"
+#include "unicode/ucnv.h"
+#include "unicode/uclean.h"
+#include "unicode/ustring.h"
+#include <mlang.h>
+#include <objbase.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*)uprv_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(){
+ uprv_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*)uprv_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(){
+ uprv_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(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(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(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(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(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(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
+
projects / apple / icu.git / blobdiff