source/test/perf/convperf/convperf.h - Issue 2435373002: Delete source/test

Side by Side Diff: source/test/perf/convperf/convperf.h

Issue 2435373002: Delete source/test (Closed)

Patch Set: Created 4 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 /*

2 **********************************************************************

3 * Copyright (c) 2002-2014, International Business Machines

4 * Corporation and others. All Rights Reserved.

5 **********************************************************************

6 **********************************************************************

7 */

8 #ifndef _CONVPERF_H

9 #define _CONVPERF_H

10

11 #include <mlang.h>

12 #include <objbase.h>

13 #include <stdlib.h>

14 #include "unicode/ucnv.h"

15 #include "unicode/uclean.h"

16 #include "unicode/ustring.h"

17 #include "cmemory.h" // for UPRV_LENGTHOF

18

19 #include "unicode/uperf.h"

20

21 #define CONVERSION_FLAGS (0) /WC_DEFAULTCHAR WC_COMPOSITECHECK & WC_SEPCHARS/

22 #define MAX_BUF_SIZE 3048

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 sour ceLen, 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;

47 target=(UChar)malloc((reqdLen) U_SIZEOF_UCHAR*2);

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(){

65 free(target);

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 s ourceLen, 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;

93 target=(char)malloc((reqdLen2));

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(){

111 free(target);

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, UEr rorCode& status){

159 name = cpName;

160 src = pszIn;

161 srcLen = szLen;

162 dstLen = UPRV_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 */

189 pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);

190 uiCodePage = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeIn fo.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 = UPRV_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 */

243 pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);

244 uiCodePage = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeIn fo.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 s ourceLen, 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 */

306 pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);

307 pMulti->CreateConvertCharset(mimeInfo.uiCodePage, 1200 /unicode/, (DWO RD)0,&pConvToUni);

308 getErr(err,status);

309 src = source;

310 srcLen = sourceLen;

311 dstLen = UPRV_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, UIN T 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 */

362 pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);

363 pMulti->CreateConvertCharset(1200 /unicode/, mimeInfo.uiCodePage, (DWO RD)0,&pConvFromUni);

364 getErr(err,status);

365 src = source;

366 srcLen = sourceLen;

367 dstLen = UPRV_LENGTHOF(dst);

368 cpName = name;

369

370 }

371

372 virtual void call(UErrorCode* status){

373 HRESULT err= pConvFromUni->DoConversionFromUnicode(src,&srcLen,dst, &dst Len);

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 = UPRV_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;

419 pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);

420 dwEnc = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.ui InternetEncoding;

421 }

422

423 virtual void call(UErrorCode* status){

424 DWORD dwMode=0;

425 HRESULT err= pMulti->ConvertStringToUnicode(&dwMode,dwEnc,(char*)src,&s rcLen,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, UI NT 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 = UPRV_LENGTHOF(dst);

469 cpName = name;

470 /* get the charset info */

471 MIMECSETINFO mimeInfo;

472 mimeInfo.uiCodePage = 0;

473 mimeInfo.uiInternetEncoding =0;

474

475 pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);

476 dwEnc = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.ui InternetEncoding;

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& statu s);

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

OLD	NEW

« no previous file with comments | « source/test/perf/convperf/Makefile.in ('k') | source/test/perf/convperf/convperf.cpp » ('j') | no next file with comments »