1 /* 2 *********************************************************************** 3 * © 2016 and later: Unicode, Inc. and others. 4 * License & terms of use: http://www.unicode.org/copyright.html#License 5 *********************************************************************** 6 *********************************************************************** 7 * Copyright (c) 2002-2016,International Business Machines 8 * Corporation and others. All Rights Reserved. 9 *********************************************************************** 10 *********************************************************************** 11 */ 12 13 #ifndef _DATEFMTPERF_H 14 #define _DATEFMTPERF_H 15 16 #include "cmemory.h" 17 #include "unicode/stringpiece.h" 18 #include "unicode/unistr.h" 19 #include "unicode/uperf.h" 20 21 #include "unicode/dtitvfmt.h" 22 #include "unicode/utypes.h" 23 #include "unicode/datefmt.h" 24 #include "unicode/calendar.h" 25 #include "unicode/uclean.h" 26 #include "unicode/brkiter.h" 27 #include "unicode/numfmt.h" 28 #include "unicode/coll.h" 29 #include "util.h" 30 31 #include "datedata.h" 32 #include "breakdata.h" 33 #include "collationdata.h" 34 35 #include <stdlib.h> 36 #include <string.h> 37 38 #include <fstream> 39 40 #include <iostream> 41 using namespace std; 42 43 // Stubs for Windows API functions when building on UNIXes. 44 // 45 #if U_PLATFORM_USES_ONLY_WIN32_API 46 // do nothing 47 #else 48 #define _UNICODE 49 typedef int DWORD; 50 inline int FoldStringW(DWORD dwMapFlags, const UChar* lpSrcStr,int cchSrc, UChar* lpDestStr,int cchDest); 51 #endif 52 53 class BreakItFunction : public UPerfFunction 54 { 55 private: 56 int num; 57 bool wordIteration; 58 59 public: 60 BreakItFunction()61 BreakItFunction(){num = -1;} BreakItFunction(int a,bool b)62 BreakItFunction(int a, bool b){num = a; wordIteration = b;} 63 call(UErrorCode * status)64 virtual void call(UErrorCode * status) 65 { 66 BreakIterator* boundary; 67 68 if(wordIteration) 69 { 70 for(int i = 0; i < num; i++) 71 { 72 boundary = BreakIterator::createWordInstance("en", *status); 73 boundary->setText(str); 74 75 int32_t start = boundary->first(); 76 for (int32_t end = boundary->next(); 77 end != BreakIterator::DONE; 78 start = end, end = boundary->next()) 79 { 80 printTextRange( *boundary, start, end ); 81 } 82 } 83 } 84 85 else // character iteration 86 { 87 for(int i = 0; i < num; i++) 88 { 89 boundary = BreakIterator::createCharacterInstance(Locale::getUS(), *status); 90 boundary->setText(str); 91 92 int32_t start = boundary->first(); 93 for (int32_t end = boundary->next(); 94 end != BreakIterator::DONE; 95 start = end, end = boundary->next()) 96 { 97 printTextRange( *boundary, start, end ); 98 } 99 } 100 } 101 102 103 } 104 getOperationsPerIteration()105 virtual long getOperationsPerIteration() 106 { 107 if(wordIteration) return 125*num; 108 else return 355*num; 109 } 110 printUnicodeString(const UnicodeString & s)111 void printUnicodeString(const UnicodeString &s) { 112 char charBuf[1000]; 113 s.extract(0, s.length(), charBuf, sizeof(charBuf)-1, 0); 114 charBuf[sizeof(charBuf)-1] = 0; 115 printf("%s", charBuf); 116 } 117 118 printTextRange(BreakIterator & iterator,int32_t start,int32_t end)119 void printTextRange( BreakIterator& iterator, 120 int32_t start, int32_t end ) 121 { 122 CharacterIterator *strIter = iterator.getText().clone(); 123 UnicodeString s; 124 strIter->getText(s); 125 //printUnicodeString(UnicodeString(s, start, end-start)); 126 //puts(""); 127 delete strIter; 128 } 129 130 // Print the given string to stdout (for debugging purposes) uprintf(const UnicodeString & str)131 void uprintf(const UnicodeString &str) { 132 char *buf = 0; 133 int32_t len = str.length(); 134 int32_t bufLen = len + 16; 135 int32_t actualLen; 136 buf = new char[bufLen + 1]; 137 actualLen = str.extract(0, len, buf/*, bufLen*/); // Default codepage conversion 138 buf[actualLen] = 0; 139 printf("%s", buf); 140 delete[] buf; 141 } 142 143 }; 144 145 class DateFmtFunction : public UPerfFunction 146 { 147 148 private: 149 int num; 150 char locale[25]; 151 public: 152 DateFmtFunction()153 DateFmtFunction() 154 { 155 num = -1; 156 } 157 DateFmtFunction(int a,const char * loc)158 DateFmtFunction(int a, const char* loc) 159 { 160 num = a; 161 strcpy(locale, loc); 162 } 163 call(UErrorCode * status)164 virtual void call(UErrorCode* status) 165 { 166 167 UErrorCode status2 = U_ZERO_ERROR; 168 Calendar *cal; 169 TimeZone *zone; 170 UnicodeString str; 171 UDate date; 172 173 cal = Calendar::createInstance(status2); 174 check(status2, "Calendar::createInstance"); 175 zone = TimeZone::createTimeZone("GMT"); // Create a GMT zone 176 cal->adoptTimeZone(zone); 177 178 Locale loc(locale); 179 DateFormat *fmt; 180 fmt = DateFormat::createDateTimeInstance( 181 DateFormat::kShort, DateFormat::kFull, loc); 182 183 184 // (dates are imported from datedata.h) 185 for(int j = 0; j < num; j++) 186 for(int i = 0; i < NUM_DATES; i++) 187 { 188 cal->clear(); 189 cal->set(years[i], months[i], days[i]); 190 date = cal->getTime(status2); 191 check(status2, "Calendar::getTime"); 192 193 fmt->setCalendar(*cal); 194 195 // Format the date 196 str.remove(); 197 fmt->format(date, str, status2); 198 199 200 // Display the formatted date string 201 //uprintf(str); 202 //printf("\n"); 203 204 } 205 206 delete fmt; 207 delete cal; 208 //u_cleanup(); 209 } 210 getOperationsPerIteration()211 virtual long getOperationsPerIteration() 212 { 213 return NUM_DATES * num; 214 } 215 216 // Print the given string to stdout (for debugging purposes) uprintf(const UnicodeString & str)217 void uprintf(const UnicodeString &str) { 218 char *buf = 0; 219 int32_t len = str.length(); 220 int32_t bufLen = len + 16; 221 int32_t actualLen; 222 buf = new char[bufLen + 1]; 223 actualLen = str.extract(0, len, buf/*, bufLen*/); // Default codepage conversion 224 buf[actualLen] = 0; 225 printf("%s", buf); 226 delete[] buf; 227 } 228 229 // Verify that a UErrorCode is successful; exit(1) if not check(UErrorCode & status,const char * msg)230 void check(UErrorCode& status, const char* msg) { 231 if (U_FAILURE(status)) { 232 printf("ERROR: %s (%s)\n", u_errorName(status), msg); 233 exit(1); 234 } 235 } 236 237 }; 238 239 class DateFmtCreateFunction : public UPerfFunction 240 { 241 242 private: 243 int num; 244 char locale[25]; 245 public: 246 DateFmtCreateFunction(int a,const char * loc)247 DateFmtCreateFunction(int a, const char* loc) 248 { 249 num = a; 250 strcpy(locale, loc); 251 } 252 call(UErrorCode *)253 virtual void call(UErrorCode* /* status */) 254 { 255 256 Locale loc(locale); 257 DateFormat *fmt; 258 // (dates are imported from datedata.h) 259 for(int j = 0; j < num; j++) { 260 fmt = DateFormat::createDateTimeInstance( 261 DateFormat::kShort, DateFormat::kFull, loc); 262 delete fmt; 263 } 264 } 265 getOperationsPerIteration()266 virtual long getOperationsPerIteration() 267 { 268 return num; 269 } 270 271 }; 272 273 class DateFmtCopyFunction : public UPerfFunction 274 { 275 276 private: 277 int num; 278 char locale[25]; 279 public: 280 DateFmtCopyFunction()281 DateFmtCopyFunction() 282 { 283 num = -1; 284 } 285 DateFmtCopyFunction(int a,const char * loc)286 DateFmtCopyFunction(int a, const char* loc) 287 { 288 num = a; 289 strcpy(locale, loc); 290 } 291 call(UErrorCode *)292 virtual void call(UErrorCode* /* status */) 293 { 294 Locale loc(locale); 295 UErrorCode status2 = U_ZERO_ERROR; 296 DateFormat *fmt = DateFormat::createDateTimeInstance( 297 DateFormat::kShort, DateFormat::kFull, loc); 298 for(int j = 0; j < num; j++) { 299 Format *cp = fmt->clone(); 300 delete cp; 301 } 302 delete fmt; 303 } 304 getOperationsPerIteration()305 virtual long getOperationsPerIteration() 306 { 307 return num; 308 } 309 310 // Verify that a UErrorCode is successful; exit(1) if not check(UErrorCode & status,const char * msg)311 void check(UErrorCode& status, const char* msg) { 312 if (U_FAILURE(status)) { 313 printf("ERROR: %s (%s)\n", u_errorName(status), msg); 314 exit(1); 315 } 316 } 317 318 }; 319 320 class DIFCreateFunction : public UPerfFunction 321 { 322 323 private: 324 int num; 325 char locale[25]; 326 public: 327 DIFCreateFunction()328 DIFCreateFunction() 329 { 330 num = -1; 331 } 332 DIFCreateFunction(int a,const char * loc)333 DIFCreateFunction(int a, const char* loc) 334 { 335 num = a; 336 strcpy(locale, loc); 337 } 338 call(UErrorCode *)339 virtual void call(UErrorCode* /* status */) 340 { 341 UErrorCode status2 = U_ZERO_ERROR; 342 Calendar *cal; 343 TimeZone *zone; 344 345 cal = Calendar::createInstance(status2); 346 check(status2, "Calendar::createInstance"); 347 zone = TimeZone::createTimeZone("GMT"); // Create a GMT zone 348 cal->adoptTimeZone(zone); 349 350 Locale loc(locale); 351 UnicodeString skeleton("yMMMMdHms"); 352 353 for(int j = 0; j < num; j++) { 354 DateIntervalFormat* fmt(DateIntervalFormat::createInstance(skeleton, loc, status2)); 355 delete fmt; 356 } 357 delete cal; 358 } 359 getOperationsPerIteration()360 virtual long getOperationsPerIteration() 361 { 362 return num; 363 } 364 365 // Verify that a UErrorCode is successful; exit(1) if not check(UErrorCode & status,const char * msg)366 void check(UErrorCode& status, const char* msg) { 367 if (U_FAILURE(status)) { 368 printf("ERROR: %s (%s)\n", u_errorName(status), msg); 369 exit(1); 370 } 371 } 372 373 }; 374 375 class TimeZoneCreateFunction : public UPerfFunction 376 { 377 378 private: 379 int num; 380 char locale[25]; 381 public: 382 TimeZoneCreateFunction()383 TimeZoneCreateFunction() 384 { 385 num = -1; 386 } 387 TimeZoneCreateFunction(int a,const char * loc)388 TimeZoneCreateFunction(int a, const char* loc) 389 { 390 num = a; 391 strcpy(locale, loc); 392 } 393 call(UErrorCode *)394 virtual void call(UErrorCode* /* status */) 395 { 396 Locale loc(locale); 397 UnicodeString tzname("UTC"); 398 for(int j = 0; j < num; j++) { 399 TimeZone* tz(TimeZone::createTimeZone(tzname)); 400 delete tz; 401 } 402 } 403 getOperationsPerIteration()404 virtual long getOperationsPerIteration() 405 { 406 return num; 407 } 408 409 // Verify that a UErrorCode is successful; exit(1) if not check(UErrorCode & status,const char * msg)410 void check(UErrorCode& status, const char* msg) { 411 if (U_FAILURE(status)) { 412 printf("ERROR: %s (%s)\n", u_errorName(status), msg); 413 exit(1); 414 } 415 } 416 417 }; 418 419 class DTPatternGeneratorCreateFunction : public UPerfFunction 420 { 421 422 private: 423 int num; 424 char locale[25]; 425 public: 426 DTPatternGeneratorCreateFunction()427 DTPatternGeneratorCreateFunction() 428 { 429 num = -1; 430 } 431 DTPatternGeneratorCreateFunction(int a,const char * loc)432 DTPatternGeneratorCreateFunction(int a, const char* loc) 433 { 434 num = a; 435 strcpy(locale, loc); 436 } 437 call(UErrorCode *)438 virtual void call(UErrorCode* /* status */) 439 { 440 UErrorCode status2 = U_ZERO_ERROR; 441 Locale loc(locale); 442 443 for(int j = 0; j < num; j++) { 444 DateTimePatternGenerator* gen(DateTimePatternGenerator::createInstance(loc, status2)); 445 delete gen; 446 } 447 } 448 getOperationsPerIteration()449 virtual long getOperationsPerIteration() 450 { 451 return num; 452 } 453 454 // Verify that a UErrorCode is successful; exit(1) if not check(UErrorCode & status,const char * msg)455 void check(UErrorCode& status, const char* msg) { 456 if (U_FAILURE(status)) { 457 printf("ERROR: %s (%s)\n", u_errorName(status), msg); 458 exit(1); 459 } 460 } 461 462 }; 463 464 class DTPatternGeneratorCopyFunction : public UPerfFunction 465 { 466 467 private: 468 int num; 469 char locale[25]; 470 public: 471 DTPatternGeneratorCopyFunction()472 DTPatternGeneratorCopyFunction() 473 { 474 num = -1; 475 } 476 DTPatternGeneratorCopyFunction(int a,const char * loc)477 DTPatternGeneratorCopyFunction(int a, const char* loc) 478 { 479 num = a; 480 strcpy(locale, loc); 481 } 482 call(UErrorCode *)483 virtual void call(UErrorCode* /* status */) 484 { 485 UErrorCode status2 = U_ZERO_ERROR; 486 Locale loc(locale); 487 DateTimePatternGenerator* gen(DateTimePatternGenerator::createInstance(loc, status2)); 488 489 for(int j = 0; j < num; j++) { 490 DateTimePatternGenerator *cl = gen->clone(); 491 delete cl; 492 } 493 delete gen; 494 } 495 getOperationsPerIteration()496 virtual long getOperationsPerIteration() 497 { 498 return num; 499 } 500 501 // Verify that a UErrorCode is successful; exit(1) if not check(UErrorCode & status,const char * msg)502 void check(UErrorCode& status, const char* msg) { 503 if (U_FAILURE(status)) { 504 printf("ERROR: %s (%s)\n", u_errorName(status), msg); 505 exit(1); 506 } 507 } 508 509 }; 510 511 class DTPatternGeneratorBestValueFunction : public UPerfFunction 512 { 513 514 private: 515 int num; 516 char locale[25]; 517 public: 518 DTPatternGeneratorBestValueFunction()519 DTPatternGeneratorBestValueFunction() 520 { 521 num = -1; 522 } 523 DTPatternGeneratorBestValueFunction(int a,const char * loc)524 DTPatternGeneratorBestValueFunction(int a, const char* loc) 525 { 526 num = a; 527 strcpy(locale, loc); 528 } 529 call(UErrorCode *)530 virtual void call(UErrorCode* /* status */) 531 { 532 UErrorCode status2 = U_ZERO_ERROR; 533 Locale loc(locale); 534 DateTimePatternGenerator* gen(DateTimePatternGenerator::createInstance(loc, status2)); 535 UnicodeString skeleton("yMMMMdHms"); 536 537 for(int j = 0; j < num; j++) { 538 gen->getBestPattern(skeleton, status2); 539 } 540 check(status2, "getBestPattern"); 541 delete gen; 542 } 543 getOperationsPerIteration()544 virtual long getOperationsPerIteration() 545 { 546 return num; 547 } 548 549 // Verify that a UErrorCode is successful; exit(1) if not check(UErrorCode & status,const char * msg)550 void check(UErrorCode& status, const char* msg) { 551 if (U_FAILURE(status)) { 552 printf("ERROR: %s (%s)\n", u_errorName(status), msg); 553 exit(1); 554 } 555 } 556 557 }; 558 559 class NumFmtFunction : public UPerfFunction 560 { 561 562 private: 563 int num; 564 char locale[25]; 565 public: 566 NumFmtFunction()567 NumFmtFunction() 568 { 569 num = -1; 570 } 571 NumFmtFunction(int a,const char * loc)572 NumFmtFunction(int a, const char* loc) 573 { 574 num = a; 575 strcpy(locale, loc); 576 } 577 call(UErrorCode * status2)578 virtual void call(UErrorCode* status2) 579 { 580 Locale loc(locale); 581 UErrorCode status = U_ZERO_ERROR; 582 583 // Create a number formatter for the locale 584 NumberFormat *fmt = NumberFormat::createInstance(loc, status); 585 586 // Parse a string. The string uses the digits '0' through '9' 587 // and the decimal separator '.', standard in the US locale 588 589 for(int i = 0; i < num; i++) 590 { 591 UnicodeString str("9876543210.123"); 592 Formattable result; 593 fmt->parse(str, result, status); 594 595 //uprintf(formattableToString(result)); 596 //printf("\n"); 597 598 // Take the number parsed above, and use the formatter to 599 // format it. 600 str.remove(); // format() will APPEND to this string 601 fmt->format(result, str, status); 602 603 //uprintf(str); 604 //printf("\n"); 605 } 606 607 delete fmt; // Release the storage used by the formatter 608 } 609 610 enum { 611 U_SPACE=0x20, 612 U_DQUOTE=0x22, 613 U_COMMA=0x2c, 614 U_LEFT_SQUARE_BRACKET=0x5b, 615 U_BACKSLASH=0x5c, 616 U_RIGHT_SQUARE_BRACKET=0x5d, 617 U_SMALL_U=0x75 618 }; 619 620 // Create a display string for a formattable formattableToString(const Formattable & f)621 UnicodeString formattableToString(const Formattable& f) { 622 switch (f.getType()) { 623 case Formattable::kDate: 624 // TODO: Finish implementing this 625 return UNICODE_STRING_SIMPLE("Formattable_DATE_TBD"); 626 case Formattable::kDouble: 627 { 628 char buf[256]; 629 sprintf(buf, "%gD", f.getDouble()); 630 return UnicodeString(buf, ""); 631 } 632 case Formattable::kLong: 633 case Formattable::kInt64: 634 { 635 char buf[256]; 636 sprintf(buf, "%ldL", f.getLong()); 637 return UnicodeString(buf, ""); 638 } 639 case Formattable::kString: 640 return UnicodeString((UChar)U_DQUOTE).append(f.getString()).append((UChar)U_DQUOTE); 641 case Formattable::kArray: 642 { 643 int32_t i, count; 644 const Formattable* array = f.getArray(count); 645 UnicodeString result((UChar)U_LEFT_SQUARE_BRACKET); 646 for (i=0; i<count; ++i) { 647 if (i > 0) { 648 (result += (UChar)U_COMMA) += (UChar)U_SPACE; 649 } 650 result += formattableToString(array[i]); 651 } 652 result += (UChar)U_RIGHT_SQUARE_BRACKET; 653 return result; 654 } 655 default: 656 return UNICODE_STRING_SIMPLE("INVALID_Formattable"); 657 } 658 } 659 getOperationsPerIteration()660 virtual long getOperationsPerIteration() 661 { 662 return num; 663 } 664 665 // Print the given string to stdout using the UTF-8 converter (for debugging purposes only) uprintf(const UnicodeString & str)666 void uprintf(const UnicodeString &str) { 667 char stackBuffer[100]; 668 char *buf = 0; 669 670 int32_t bufLen = str.extract(0, 0x7fffffff, stackBuffer, sizeof(stackBuffer), "UTF-8"); 671 if(bufLen < sizeof(stackBuffer)) { 672 buf = stackBuffer; 673 } else { 674 buf = new char[bufLen + 1]; 675 bufLen = str.extract(0, 0x7fffffff, buf, bufLen + 1, "UTF-8"); 676 } 677 printf("%s", buf); 678 if(buf != stackBuffer) { 679 delete[] buf; 680 } 681 } 682 }; 683 684 685 686 #define NUM_STRING "9876543210.123" 687 #define NUM_NUM 9876543210.123 688 class StdioNumFmtFunction : public UPerfFunction 689 { 690 691 private: 692 int num; 693 char locale[25]; 694 public: 695 StdioNumFmtFunction()696 StdioNumFmtFunction() 697 { 698 num = -1; 699 } 700 StdioNumFmtFunction(int a,const char * loc)701 StdioNumFmtFunction(int a, const char* loc) 702 { 703 num = a; 704 strcpy(locale, loc); 705 } 706 call(UErrorCode * status2)707 virtual void call(UErrorCode* status2) 708 { 709 Locale loc(locale); 710 UErrorCode status = U_ZERO_ERROR; 711 712 // Parse a string. The string uses the digits '0' through '9' 713 // and the decimal separator '.', standard in the US locale 714 715 double result; 716 char outbuf[500]; 717 const char *str = NUM_STRING; 718 719 for(int i = 0; i < num; i++) 720 { 721 if(sscanf(str, "%lg", &result)!=1) { 722 cout << "Failed Stdio: failed to sscanf" << endl; 723 *status2 = U_PARSE_ERROR; 724 return; 725 } 726 727 sprintf(outbuf, "%lg", result); 728 } 729 730 if(result!=NUM_NUM) { 731 cout << "Failed Stdio: sscanf got wrong result, expected " << NUM_NUM << " got " << result << endl; 732 *status2 = U_PARSE_ERROR; 733 } 734 if(strcmp(str,NUM_STRING)) { 735 cout << "Failed Stdio: sprintf got wrong result, expected " << NUM_STRING << " got " << str << endl; 736 *status2 = U_PARSE_ERROR; 737 } 738 } 739 getOperationsPerIteration()740 virtual long getOperationsPerIteration() 741 { 742 return num; 743 } 744 745 }; 746 747 class CollationFunction : public UPerfFunction 748 { 749 750 private: 751 int num; 752 char locale[25]; 753 UnicodeString *collation_strings; 754 755 /** 756 * Unescape the strings 757 */ init()758 void init() { 759 uint32_t listSize = UPRV_LENGTHOF(collation_strings_escaped); 760 collation_strings = new UnicodeString[listSize]; 761 for(uint32_t k=0;k<listSize;k++) { 762 collation_strings[k] = collation_strings_escaped[k].unescape(); 763 } 764 UnicodeString shorty((UChar32)0x12345); 765 } 766 public: 767 CollationFunction()768 CollationFunction() 769 { 770 num = -1; 771 772 init(); 773 } 774 ~CollationFunction()775 ~CollationFunction() { 776 delete [] collation_strings; 777 } 778 CollationFunction(int a,const char * loc)779 CollationFunction(int a, const char* loc) 780 { 781 num = a; 782 strcpy(locale, loc); 783 init(); 784 } 785 call(UErrorCode * status2)786 virtual void call(UErrorCode* status2) 787 { 788 uint32_t listSize = UPRV_LENGTHOF(collation_strings_escaped); 789 UErrorCode status = U_ZERO_ERROR; 790 Collator *coll = Collator::createInstance(Locale(locale), status); 791 792 for(int k = 0; k < num; k++) 793 { 794 uint32_t i, j; 795 for(i=listSize-1; i>=1; i--) { 796 for(j=0; j<i; j++) { 797 if(coll->compare(collation_strings[j], collation_strings[j+1]) == UCOL_LESS) { 798 //cout << "Success!" << endl; 799 } 800 } 801 } 802 } 803 delete coll; 804 } 805 getOperationsPerIteration()806 virtual long getOperationsPerIteration() 807 { 808 return num; 809 } 810 }; 811 812 class DateFormatPerfTest : public UPerfTest 813 { 814 private: 815 816 public: 817 818 DateFormatPerfTest(int32_t argc, const char* argv[], UErrorCode& status); 819 ~DateFormatPerfTest(); 820 virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const char* &name, char* par); 821 822 UPerfFunction* DateFmt250(); 823 UPerfFunction* DateFmt10000(); 824 UPerfFunction* DateFmt100000(); 825 UPerfFunction* DateFmtCreate250(); 826 UPerfFunction* DateFmtCreate10000(); 827 UPerfFunction* DateFmtCopy250(); 828 UPerfFunction* DateFmtCopy10000(); 829 UPerfFunction* BreakItWord250(); 830 UPerfFunction* BreakItWord10000(); 831 UPerfFunction* BreakItChar250(); 832 UPerfFunction* BreakItChar10000(); 833 UPerfFunction* NumFmt10000(); 834 UPerfFunction* NumFmt100000(); 835 UPerfFunction* Collation10000(); 836 UPerfFunction* Collation100000(); 837 UPerfFunction* DIFCreate250(); 838 UPerfFunction* DIFCreate10000(); 839 UPerfFunction* TimeZoneCreate250(); 840 UPerfFunction* TimeZoneCreate10000(); 841 UPerfFunction* DTPatternGeneratorCreate250(); 842 UPerfFunction* DTPatternGeneratorCreate10000(); 843 UPerfFunction* DTPatternGeneratorCopy250(); 844 UPerfFunction* DTPatternGeneratorCopy10000(); 845 UPerfFunction* DTPatternGeneratorBestValue250(); 846 UPerfFunction* DTPatternGeneratorBestValue10000(); 847 }; 848 849 #endif // DateFmtPerf 850