OLD | NEW |
1 /* | 1 /* |
2 ********************************************************************** | 2 ********************************************************************** |
3 * Copyright (c) 2002-2011,International Business Machines | 3 * Copyright (c) 2002-2014,International Business Machines |
4 * Corporation and others. All Rights Reserved. | 4 * Corporation and others. All Rights Reserved. |
5 ********************************************************************** | 5 ********************************************************************** |
6 ********************************************************************** | 6 ********************************************************************** |
7 */ | 7 */ |
8 | 8 |
9 #ifndef _DATEFMTPERF_H | 9 #ifndef _DATEFMTPERF_H |
10 #define _DATEFMTPERF_H | 10 #define _DATEFMTPERF_H |
11 | 11 |
12 | 12 |
13 #include "unicode/stringpiece.h" | 13 #include "unicode/stringpiece.h" |
14 #include "unicode/unistr.h" | 14 #include "unicode/unistr.h" |
15 #include "unicode/uperf.h" | 15 #include "unicode/uperf.h" |
16 | 16 |
| 17 #include "unicode/dtitvfmt.h" |
17 #include "unicode/utypes.h" | 18 #include "unicode/utypes.h" |
18 #include "unicode/datefmt.h" | 19 #include "unicode/datefmt.h" |
19 #include "unicode/calendar.h" | 20 #include "unicode/calendar.h" |
20 #include "unicode/uclean.h" | 21 #include "unicode/uclean.h" |
21 #include "unicode/brkiter.h" | 22 #include "unicode/brkiter.h" |
22 #include "unicode/numfmt.h" | 23 #include "unicode/numfmt.h" |
23 #include "unicode/coll.h" | 24 #include "unicode/coll.h" |
24 #include "util.h" | 25 #include "util.h" |
25 | 26 |
26 #include "datedata.h" | 27 #include "datedata.h" |
(...skipping 22 matching lines...) Expand all Loading... |
49 { | 50 { |
50 private: | 51 private: |
51 int num; | 52 int num; |
52 bool wordIteration; | 53 bool wordIteration; |
53 | 54 |
54 public: | 55 public: |
55 | 56 |
56 BreakItFunction(){num = -1;} | 57 BreakItFunction(){num = -1;} |
57 BreakItFunction(int a, bool b){num = a; wordIteration = b;} | 58 BreakItFunction(int a, bool b){num = a; wordIteration = b;} |
58 | 59 |
59 » virtual void call(UErrorCode *status) | 60 » virtual void call(UErrorCode * status) |
60 { | 61 { |
61 BreakIterator* boundary; | 62 BreakIterator* boundary; |
62 | 63 |
63 if(wordIteration) | 64 if(wordIteration) |
64 { | 65 { |
65 for(int i = 0; i < num; i++) | 66 for(int i = 0; i < num; i++) |
66 { | 67 { |
67 boundary = BreakIterator::createWordInstance("en
", *status); | 68 boundary = BreakIterator::createWordInstance("en
", *status); |
68 boundary->setText(str); | 69 boundary->setText(str); |
69 | 70 |
(...skipping 154 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
224 // Verify that a UErrorCode is successful; exit(1) if not | 225 // Verify that a UErrorCode is successful; exit(1) if not |
225 void check(UErrorCode& status, const char* msg) { | 226 void check(UErrorCode& status, const char* msg) { |
226 if (U_FAILURE(status)) { | 227 if (U_FAILURE(status)) { |
227 printf("ERROR: %s (%s)\n", u_errorName(status), msg); | 228 printf("ERROR: %s (%s)\n", u_errorName(status), msg); |
228 exit(1); | 229 exit(1); |
229 } | 230 } |
230 } | 231 } |
231 | 232 |
232 }; | 233 }; |
233 | 234 |
| 235 class DateFmtCreateFunction : public UPerfFunction |
| 236 { |
| 237 |
| 238 private: |
| 239 int num; |
| 240 char locale[25]; |
| 241 public: |
| 242 |
| 243 DateFmtCreateFunction(int a, const char* loc) |
| 244 { |
| 245 num = a; |
| 246 strcpy(locale, loc); |
| 247 } |
| 248 |
| 249 virtual void call(UErrorCode* /* status */) |
| 250 { |
| 251 |
| 252 Locale loc(locale); |
| 253 DateFormat *fmt; |
| 254 // (dates are imported from datedata.h) |
| 255 for(int j = 0; j < num; j++) { |
| 256 fmt = DateFormat::createDateTimeInstance( |
| 257 DateFormat::kShort, DateFormat::kFull, loc); |
| 258 delete fmt; |
| 259 } |
| 260 } |
| 261 |
| 262 virtual long getOperationsPerIteration() |
| 263 { |
| 264 return num; |
| 265 } |
| 266 |
| 267 }; |
| 268 |
| 269 class DateFmtCopyFunction : public UPerfFunction |
| 270 { |
| 271 |
| 272 private: |
| 273 int num; |
| 274 char locale[25]; |
| 275 public: |
| 276 |
| 277 DateFmtCopyFunction() |
| 278 { |
| 279 num = -1; |
| 280 } |
| 281 |
| 282 DateFmtCopyFunction(int a, const char* loc) |
| 283 { |
| 284 num = a; |
| 285 strcpy(locale, loc); |
| 286 } |
| 287 |
| 288 virtual void call(UErrorCode* /* status */) |
| 289 { |
| 290 Locale loc(locale); |
| 291 UErrorCode status2 = U_ZERO_ERROR; |
| 292 DateFormat *fmt = DateFormat::createDateTimeInstance( |
| 293 DateFormat::kShort, DateFormat::kFull, loc); |
| 294 for(int j = 0; j < num; j++) { |
| 295 Format *cp = fmt->clone(); |
| 296 delete cp; |
| 297 } |
| 298 delete fmt; |
| 299 } |
| 300 |
| 301 virtual long getOperationsPerIteration() |
| 302 { |
| 303 return num; |
| 304 } |
| 305 |
| 306 // Verify that a UErrorCode is successful; exit(1) if not |
| 307 void check(UErrorCode& status, const char* msg) { |
| 308 if (U_FAILURE(status)) { |
| 309 printf("ERROR: %s (%s)\n", u_errorName(status), msg); |
| 310 exit(1); |
| 311 } |
| 312 } |
| 313 |
| 314 }; |
| 315 |
| 316 class DIFCreateFunction : public UPerfFunction |
| 317 { |
| 318 |
| 319 private: |
| 320 int num; |
| 321 char locale[25]; |
| 322 public: |
| 323 |
| 324 DIFCreateFunction() |
| 325 { |
| 326 num = -1; |
| 327 } |
| 328 |
| 329 DIFCreateFunction(int a, const char* loc) |
| 330 { |
| 331 num = a; |
| 332 strcpy(locale, loc); |
| 333 } |
| 334 |
| 335 virtual void call(UErrorCode* /* status */) |
| 336 { |
| 337 UErrorCode status2 = U_ZERO_ERROR; |
| 338 Calendar *cal; |
| 339 TimeZone *zone; |
| 340 |
| 341 cal = Calendar::createInstance(status2); |
| 342 check(status2, "Calendar::createInstance"); |
| 343 zone = TimeZone::createTimeZone("GMT"); // Create a GMT zone |
| 344 cal->adoptTimeZone(zone); |
| 345 |
| 346 Locale loc(locale); |
| 347 UnicodeString skeleton("yMMMMdHms"); |
| 348 |
| 349 for(int j = 0; j < num; j++) { |
| 350 DateIntervalFormat* fmt(DateIntervalFormat::createInstance(s
keleton, loc, status2)); |
| 351 delete fmt; |
| 352 } |
| 353 delete cal; |
| 354 } |
| 355 |
| 356 virtual long getOperationsPerIteration() |
| 357 { |
| 358 return num; |
| 359 } |
| 360 |
| 361 // Verify that a UErrorCode is successful; exit(1) if not |
| 362 void check(UErrorCode& status, const char* msg) { |
| 363 if (U_FAILURE(status)) { |
| 364 printf("ERROR: %s (%s)\n", u_errorName(status), msg); |
| 365 exit(1); |
| 366 } |
| 367 } |
| 368 |
| 369 }; |
| 370 |
| 371 class TimeZoneCreateFunction : public UPerfFunction |
| 372 { |
| 373 |
| 374 private: |
| 375 int num; |
| 376 char locale[25]; |
| 377 public: |
| 378 |
| 379 TimeZoneCreateFunction() |
| 380 { |
| 381 num = -1; |
| 382 } |
| 383 |
| 384 TimeZoneCreateFunction(int a, const char* loc) |
| 385 { |
| 386 num = a; |
| 387 strcpy(locale, loc); |
| 388 } |
| 389 |
| 390 virtual void call(UErrorCode* /* status */) |
| 391 { |
| 392 Locale loc(locale); |
| 393 UnicodeString tzname("UTC"); |
| 394 for(int j = 0; j < num; j++) { |
| 395 TimeZone* tz(TimeZone::createTimeZone(tzname)); |
| 396 delete tz; |
| 397 } |
| 398 } |
| 399 |
| 400 virtual long getOperationsPerIteration() |
| 401 { |
| 402 return num; |
| 403 } |
| 404 |
| 405 // Verify that a UErrorCode is successful; exit(1) if not |
| 406 void check(UErrorCode& status, const char* msg) { |
| 407 if (U_FAILURE(status)) { |
| 408 printf("ERROR: %s (%s)\n", u_errorName(status), msg); |
| 409 exit(1); |
| 410 } |
| 411 } |
| 412 |
| 413 }; |
| 414 |
| 415 class DTPatternGeneratorCreateFunction : public UPerfFunction |
| 416 { |
| 417 |
| 418 private: |
| 419 int num; |
| 420 char locale[25]; |
| 421 public: |
| 422 |
| 423 DTPatternGeneratorCreateFunction() |
| 424 { |
| 425 num = -1; |
| 426 } |
| 427 |
| 428 DTPatternGeneratorCreateFunction(int a, const char* loc) |
| 429 { |
| 430 num = a; |
| 431 strcpy(locale, loc); |
| 432 } |
| 433 |
| 434 virtual void call(UErrorCode* /* status */) |
| 435 { |
| 436 UErrorCode status2 = U_ZERO_ERROR; |
| 437 Locale loc(locale); |
| 438 |
| 439 for(int j = 0; j < num; j++) { |
| 440 DateTimePatternGenerator* gen(DateTimePatternGenerator::crea
teInstance(loc, status2)); |
| 441 delete gen; |
| 442 } |
| 443 } |
| 444 |
| 445 virtual long getOperationsPerIteration() |
| 446 { |
| 447 return num; |
| 448 } |
| 449 |
| 450 // Verify that a UErrorCode is successful; exit(1) if not |
| 451 void check(UErrorCode& status, const char* msg) { |
| 452 if (U_FAILURE(status)) { |
| 453 printf("ERROR: %s (%s)\n", u_errorName(status), msg); |
| 454 exit(1); |
| 455 } |
| 456 } |
| 457 |
| 458 }; |
| 459 |
| 460 class DTPatternGeneratorCopyFunction : public UPerfFunction |
| 461 { |
| 462 |
| 463 private: |
| 464 int num; |
| 465 char locale[25]; |
| 466 public: |
| 467 |
| 468 DTPatternGeneratorCopyFunction() |
| 469 { |
| 470 num = -1; |
| 471 } |
| 472 |
| 473 DTPatternGeneratorCopyFunction(int a, const char* loc) |
| 474 { |
| 475 num = a; |
| 476 strcpy(locale, loc); |
| 477 } |
| 478 |
| 479 virtual void call(UErrorCode* /* status */) |
| 480 { |
| 481 UErrorCode status2 = U_ZERO_ERROR; |
| 482 Locale loc(locale); |
| 483 DateTimePatternGenerator* gen(DateTimePatternGenerator::createIn
stance(loc, status2)); |
| 484 |
| 485 for(int j = 0; j < num; j++) { |
| 486 DateTimePatternGenerator *cl = gen->clone(); |
| 487 delete cl; |
| 488 } |
| 489 delete gen; |
| 490 } |
| 491 |
| 492 virtual long getOperationsPerIteration() |
| 493 { |
| 494 return num; |
| 495 } |
| 496 |
| 497 // Verify that a UErrorCode is successful; exit(1) if not |
| 498 void check(UErrorCode& status, const char* msg) { |
| 499 if (U_FAILURE(status)) { |
| 500 printf("ERROR: %s (%s)\n", u_errorName(status), msg); |
| 501 exit(1); |
| 502 } |
| 503 } |
| 504 |
| 505 }; |
| 506 |
| 507 class DTPatternGeneratorBestValueFunction : public UPerfFunction |
| 508 { |
| 509 |
| 510 private: |
| 511 int num; |
| 512 char locale[25]; |
| 513 public: |
| 514 |
| 515 DTPatternGeneratorBestValueFunction() |
| 516 { |
| 517 num = -1; |
| 518 } |
| 519 |
| 520 DTPatternGeneratorBestValueFunction(int a, const char* loc) |
| 521 { |
| 522 num = a; |
| 523 strcpy(locale, loc); |
| 524 } |
| 525 |
| 526 virtual void call(UErrorCode* /* status */) |
| 527 { |
| 528 UErrorCode status2 = U_ZERO_ERROR; |
| 529 Locale loc(locale); |
| 530 DateTimePatternGenerator* gen(DateTimePatternGenerator::createIn
stance(loc, status2)); |
| 531 UnicodeString skeleton("yMMMMdHms"); |
| 532 |
| 533 for(int j = 0; j < num; j++) { |
| 534 gen->getBestPattern(skeleton, status2); |
| 535 } |
| 536 check(status2, "getBestPattern"); |
| 537 delete gen; |
| 538 } |
| 539 |
| 540 virtual long getOperationsPerIteration() |
| 541 { |
| 542 return num; |
| 543 } |
| 544 |
| 545 // Verify that a UErrorCode is successful; exit(1) if not |
| 546 void check(UErrorCode& status, const char* msg) { |
| 547 if (U_FAILURE(status)) { |
| 548 printf("ERROR: %s (%s)\n", u_errorName(status), msg); |
| 549 exit(1); |
| 550 } |
| 551 } |
| 552 |
| 553 }; |
| 554 |
234 class NumFmtFunction : public UPerfFunction | 555 class NumFmtFunction : public UPerfFunction |
235 { | 556 { |
236 | 557 |
237 private: | 558 private: |
238 int num; | 559 int num; |
239 char locale[25]; | 560 char locale[25]; |
240 public: | 561 public: |
241 | 562 |
242 NumFmtFunction() | 563 NumFmtFunction() |
243 { | 564 { |
(...skipping 246 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
490 | 811 |
491 public: | 812 public: |
492 | 813 |
493 DateFormatPerfTest(int32_t argc, const char* argv[], UErrorCode& status)
; | 814 DateFormatPerfTest(int32_t argc, const char* argv[], UErrorCode& status)
; |
494 ~DateFormatPerfTest(); | 815 ~DateFormatPerfTest(); |
495 virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const ch
ar* &name, char* par); | 816 virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const ch
ar* &name, char* par); |
496 | 817 |
497 UPerfFunction* DateFmt250(); | 818 UPerfFunction* DateFmt250(); |
498 UPerfFunction* DateFmt10000(); | 819 UPerfFunction* DateFmt10000(); |
499 UPerfFunction* DateFmt100000(); | 820 UPerfFunction* DateFmt100000(); |
| 821 UPerfFunction* DateFmtCreate250(); |
| 822 UPerfFunction* DateFmtCreate10000(); |
| 823 UPerfFunction* DateFmtCopy250(); |
| 824 UPerfFunction* DateFmtCopy10000(); |
500 UPerfFunction* BreakItWord250(); | 825 UPerfFunction* BreakItWord250(); |
501 UPerfFunction* BreakItWord10000(); | 826 UPerfFunction* BreakItWord10000(); |
502 UPerfFunction* BreakItChar250(); | 827 UPerfFunction* BreakItChar250(); |
503 UPerfFunction* BreakItChar10000(); | 828 UPerfFunction* BreakItChar10000(); |
504 UPerfFunction* NumFmt10000(); | 829 UPerfFunction* NumFmt10000(); |
505 UPerfFunction* NumFmt100000(); | 830 UPerfFunction* NumFmt100000(); |
506 UPerfFunction* Collation10000(); | 831 UPerfFunction* Collation10000(); |
507 UPerfFunction* Collation100000(); | 832 UPerfFunction* Collation100000(); |
| 833 UPerfFunction* DIFCreate250(); |
| 834 UPerfFunction* DIFCreate10000(); |
| 835 UPerfFunction* TimeZoneCreate250(); |
| 836 UPerfFunction* TimeZoneCreate10000(); |
| 837 UPerfFunction* DTPatternGeneratorCreate250(); |
| 838 UPerfFunction* DTPatternGeneratorCreate10000(); |
| 839 UPerfFunction* DTPatternGeneratorCopy250(); |
| 840 UPerfFunction* DTPatternGeneratorCopy10000(); |
| 841 UPerfFunction* DTPatternGeneratorBestValue250(); |
| 842 UPerfFunction* DTPatternGeneratorBestValue10000(); |
508 }; | 843 }; |
509 | 844 |
510 #endif // DateFmtPerf | 845 #endif // DateFmtPerf |
OLD | NEW |