icuSources/test/perf/howExpensiveIs/howExpensiveIs.cpp

   1 /*
   2  **********************************************************************
   3  * Copyright (c) 2011-2014,International Business Machines
   4  * Corporation and others.  All Rights Reserved.
   5  **********************************************************************
   6  */
   7 #include <stdio.h>
   8 #include <string.h>
   9
  10 #include "sieve.h"
  11 #include "unicode/utimer.h"
  12 #include "udbgutil.h"
  13 #include "unicode/ustring.h"
  14 #include "unicode/decimfmt.h"
  15 #include "unicode/udat.h"
  16 U_NAMESPACE_USE
  17
  18 #if U_PLATFORM_IMPLEMENTS_POSIX
  19 #include <unistd.h>
  20
  21 static void usage(const char *prog) {
  22   fprintf(stderr, "Usage: %s [ -f outfile.xml ] [ -t 'TestName' ]\n", prog);
  23 }
  24 #endif
  25
  26 void runTests(void);
  27
  28 #ifndef ITERATIONS
  29 #define ITERATIONS 5
  30 #endif
  31
  32 #ifndef TEST_LOCALE
  33 #define TEST_LOCALE "en_US"
  34 #endif
  35
  36 FILE *out = NULL;
  37 UErrorCode setupStatus = U_ZERO_ERROR;
  38 const char *outName = NULL;
  39 int listmode = 0;
  40 const char *testName = NULL;
  41 const char *progname = NULL;
  42 int errflg = 0;
  43 int testhit = 0;
  44
  45 int testMatch(const char *aName) {
  46   if(testName==NULL) return 1;
  47   int len = strlen(testName);
  48   if(testName[len-1]=='*') {
  49     return strncmp(testName,aName,len-1);
  50   } else {
  51     return strcmp(testName,aName);
  52   }
  53 }
  54
  55 int main(int argc, char * const * argv){
  56 #if U_DEBUG
  57   fprintf(stderr,"%s: warning: U_DEBUG is on.\n", argv[0]);
  58 #endif
  59 #if U_DEBUG
  60   {
  61     double m;
  62     double s = uprv_getSieveTime(&m);
  63     fprintf(stderr, "** Standard sieve time: %.9fs +/- %.9fs (%d iterations)\n", s,m, (int)U_LOTS_OF_TIMES);
  64   }
  65 #endif
  66
  67 #if U_PLATFORM_IMPLEMENTS_POSIX
  68   int c;
  69   //extern int optind;
  70   extern char *optarg;
  71   while((c=getopt(argc,argv,"lf:t:")) != EOF) {
  72     switch(c) {
  73     case 'f':
  74       outName = optarg;
  75       break;
  76     case 'l':
  77       listmode++;
  78       break;
  79     case 't':
  80       testName = optarg;
  81       break;
  82     case '?':
  83       errflg++;
  84     }
  85     if(errflg) {
  86       usage(progname);
  87       return 0;
  88     }
  89   }
  90   /* for ( ; optind < argc; optind++) {     ... argv[optind] } */
  91 #else
  92   if(argc==2) {
  93     outName = argv[1];
  94   } else if(argc>2) {
  95     fprintf(stderr, "Err: usage: %s [ output-file.xml ]\n", argv[0]);
  96   }
  97 #endif
  98
  99     if(listmode && outName != NULL ) {
 100       fprintf(stderr, "Warning: no output when list mode\n");
 101       outName=NULL;
 102     }
 103
 104   if(outName != NULL) {
 105
 106
 107     out=fopen(outName,"w");
 108     if(out==NULL) {
 109       fprintf(stderr,"Err: can't open %s for writing.\n", outName);
 110       return 1;
 111     } else {
 112       fprintf(stderr, "# writing results to %s\n", outName);
 113     }
 114     fprintf(out, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
 115     fprintf(out, "<tests icu=\"%s\">\n", U_ICU_VERSION);
 116     fprintf(out, "<!-- %s -->\n", U_COPYRIGHT_STRING);
 117   } else {
 118     fprintf(stderr, "# (no output)\n");
 119   }
 120
 121   if(listmode && testName!=NULL) {
 122     fprintf(stderr, "ERR: no -l mode when specific test with -t\n");
 123     usage(progname);
 124     return 1;
 125   }
 126
 127
 128   runTests();
 129
 130
 131   if(out!=NULL) {
 132 #ifndef SKIP_INFO
 133     udbg_writeIcuInfo(out);
 134 #endif
 135     fprintf(out, "</tests>\n");
 136     fclose(out);
 137   }
 138
 139   if(U_FAILURE(setupStatus)) {
 140     fprintf(stderr, "Error in tests: %s\n", u_errorName(setupStatus));
 141     return 1;
 142   }
 143
 144   return 0;
 145 }
 146
 147 class HowExpensiveTest {
 148 public:
 149   virtual ~HowExpensiveTest(){}
 150 protected:
 151   HowExpensiveTest(const char *name, const char *file, int32_t line) : fName(name), fFile(file), fLine(line) {}
 152 protected:
 153   /**
 154    * @return number of iterations
 155    */
 156   virtual int32_t run() = 0;
 157   virtual void warmup() {  run(); }
 158 public:
 159   virtual const char *getName() { return fName; }
 160 public:
 161   virtual int32_t runTest(double *subTime) {
 162     UTimer a,b;
 163     utimer_getTime(&a);
 164     int32_t iter = run();
 165     utimer_getTime(&b);
 166     *subTime = utimer_getDeltaSeconds(&a,&b);
 167     return iter;
 168   }
 169
 170   virtual int32_t runTests(double *subTime, double *marginOfError) {
 171     warmup(); /* warmup */
 172     double times[ITERATIONS];
 173     int subIterations = 0;
 174     for(int i=0;i<ITERATIONS;i++) {
 175       subIterations = runTest(&times[i]);
 176 #if U_DEBUG
 177       fprintf(stderr, "trial: %d/%d = %.9fs\n", i, ITERATIONS,times[i]);
 178       fflush(stderr);
 179 #endif
 180     }
 181     uint32_t iterations = ITERATIONS;
 182     *subTime = uprv_getMeanTime(times,&iterations,marginOfError);
 183     return subIterations;
 184   }
 185 public:
 186   const char *fName;
 187   const char *fFile;
 188   int32_t fLine;
 189   int32_t fIterations;
 190 };
 191
 192 void runTestOn(HowExpensiveTest &t) {
 193   if(U_FAILURE(setupStatus)) return; // silently
 194   const char *tn = t.getName();
 195   if(testName!=NULL && testMatch(tn)) return; // skipped.
 196   if(listmode) {
 197     fprintf(stderr, "%s:%d:\t%s\n", t.fFile, t.fLine, t.getName());
 198     testhit++;
 199     return;
 200   } else {
 201     fprintf(stderr, "%s:%d: Running: %s\n", t.fFile, t.fLine, t.getName());
 202     testhit++;
 203   }
 204   double sieveTime = uprv_getSieveTime(NULL);
 205   double st;
 206   double me;
 207
 208   fflush(stdout);
 209   fflush(stderr);
 210   int32_t iter = t.runTests(&st,&me);
 211   if(U_FAILURE(setupStatus)) {
 212     fprintf(stderr, "Error in tests: %s\n", u_errorName(setupStatus));
 213     return;
 214   }
 215   fflush(stdout);
 216   fflush(stderr);
 217
 218   double stn = st/sieveTime;
 219
 220   printf("%s\t%.9f\t%.9f +/- %.9f,  @ %d iter\n", t.getName(),stn,st,me,iter);
 221
 222   if(out!=NULL) {
 223     fprintf(out, "   <test name=\"%s\" standardizedTime=\"%f\" realDuration=\"%f\" marginOfError=\"%f\" iterations=\"%d\" />\n",
 224             tn,stn,st,me,iter);
 225     fflush(out);
 226   }
 227 }
 228
 229 /* ------------------- test code here --------------------- */
 230
 231 class SieveTest : public HowExpensiveTest {
 232 public:
 233   virtual ~SieveTest(){}
 234   SieveTest():HowExpensiveTest("SieveTest",__FILE__,__LINE__){}
 235   virtual int32_t run(){return 0;} // dummy
 236   int32_t runTest(double *subTime) {
 237     *subTime = uprv_getSieveTime(NULL);
 238     return U_LOTS_OF_TIMES;
 239   }
 240   virtual int32_t runTests(double *subTime, double *marginOfError) {
 241     *subTime = uprv_getSieveTime(marginOfError);
 242     return U_LOTS_OF_TIMES;
 243   }
 244 };
 245
 246
 247 /* ------- NumParseTest ------------- */
 248 #include "unicode/unum.h"
 249 /* open and close tests */
 250 #define OCName(svc,ub,testn,suffix,n) testn ## svc ## ub ## suffix ## n
 251 #define OCStr(svc,ub,suffix,n) "Test_" # svc # ub # suffix # n
 252 #define OCRun(svc,ub,suffix) svc ## ub ## suffix
 253 // TODO: run away screaming
 254 #define OpenCloseTest(n, svc,suffix,c,a,d) class OCName(svc,_,Test_,suffix,n) : public HowExpensiveTest { public: OCName(svc,_,Test_,suffix,n)():HowExpensiveTest(OCStr(svc,_,suffix,n),__FILE__,__LINE__) c int32_t run() { int32_t i; for(i=0;i<U_LOTS_OF_TIMES;i++){ OCRun(svc,_,close) (  OCRun(svc,_,suffix) a );  } return i; }   void warmup() { OCRun(svc,_,close) ( OCRun(svc,_,suffix) a); } virtual ~ OCName(svc,_,Test_,suffix,n) () d };
 255 #define QuickTest(n,c,r,d)  class n : public HowExpensiveTest { public: n():HowExpensiveTest(#n,__FILE__,__LINE__) c int32_t run() r virtual ~n () d };
 256
 257 class NumTest : public HowExpensiveTest {
 258 private:
 259   double fExpect;
 260   UNumberFormat *fFmt;
 261   UnicodeString fPat;
 262   UnicodeString fString;
 263   const UChar *fStr;
 264   int32_t fLen;
 265   const char *fFile;
 266   int fLine;
 267   const char *fCPat;
 268   const char *fCStr;
 269   char name[100];
 270 public:
 271   virtual const char *getName() {
 272     if(name[0]==0) {
 273       sprintf(name,"%s:p=|%s|,str=|%s|",getClassName(),fCPat,fCStr);
 274     }
 275     return name;
 276   }
 277 protected:
 278   virtual UNumberFormat* initFmt() {
 279     return unum_open(UNUM_PATTERN_DECIMAL, fPat.getTerminatedBuffer(), -1, TEST_LOCALE, 0, &setupStatus);
 280   }
 281   virtual const char *getClassName() {
 282     return "NumTest";
 283   }
 284 public:
 285   NumTest(const char *pat, const char *num, double expect, const char *FILE, int LINE)
 286     : HowExpensiveTest("(n/a)",FILE, LINE),
 287       fExpect(expect),
 288       fFmt(0),
 289       fPat(pat, -1, US_INV),
 290       fString(num,-1,US_INV),
 291       fStr(fString.getTerminatedBuffer()),
 292       fLen(u_strlen(fStr)),
 293       fFile(FILE),
 294       fLine(LINE),
 295       fCPat(pat),
 296       fCStr(num)
 297   {
 298     name[0]=0;
 299   }
 300   void warmup() {
 301     fFmt = initFmt();
 302     if(U_SUCCESS(setupStatus)) {
 303       double trial = unum_parseDouble(fFmt,fStr,fLen, NULL, &setupStatus);
 304       if(U_SUCCESS(setupStatus) && trial!=fExpect) {
 305         setupStatus = U_INTERNAL_PROGRAM_ERROR;
 306         printf("%s:%d: warmup() %s got %.8f expected %.8f\n",
 307                fFile,fLine,getName(),trial,fExpect);
 308       }
 309     }
 310   }
 311   int32_t run() {
 312     double trial=0.0;
 313     int i;
 314     for(i=0;i<U_LOTS_OF_TIMES;i++){
 315       trial = unum_parse(fFmt,fStr,fLen, NULL, &setupStatus);
 316     }
 317     return i;
 318   }
 319   virtual ~NumTest(){}
 320 };
 321
 322 #define DO_NumTest(p,n,x) { NumTest t(p,n,x,__FILE__,__LINE__); runTestOn(t); }
 323
 324
 325 class AttrNumTest : public NumTest
 326 {
 327 private:
 328   UNumberFormatAttribute fAttr;
 329   int32_t fAttrValue;
 330   char name2[100];
 331 protected:
 332   virtual const char *getClassName() {
 333     sprintf(name2,"AttrNumTest:%d=%d", fAttr,fAttrValue);
 334     return name2;
 335   }
 336 public:
 337   AttrNumTest(const char *pat, const char *num, double expect, const char *FILE, int LINE, UNumberFormatAttribute attr, int32_t newValue)
 338     : NumTest(pat,num,expect,FILE,LINE),
 339       fAttr(attr),
 340       fAttrValue(newValue)
 341   {
 342   }
 343   virtual UNumberFormat* initFmt() {
 344     UNumberFormat *fmt = NumTest::initFmt();
 345     unum_setAttribute(fmt, fAttr,fAttrValue);
 346     return fmt;
 347   }
 348 };
 349
 350 #define DO_AttrNumTest(p,n,x,a,v) { AttrNumTest t(p,n,x,__FILE__,__LINE__,a,v); runTestOn(t); }
 351
 352
 353 class NOXNumTest : public NumTest
 354 {
 355 private:
 356   UNumberFormatAttribute fAttr;
 357   int32_t fAttrValue;
 358   char name2[100];
 359 protected:
 360   virtual const char *getClassName() {
 361     sprintf(name2,"NOXNumTest:%d=%d", fAttr,fAttrValue);
 362     return name2;
 363   }
 364 public:
 365   NOXNumTest(const char *pat, const char *num, double expect, const char *FILE, int LINE /*, UNumberFormatAttribute attr, int32_t newValue */)
 366     : NumTest(pat,num,expect,FILE,LINE) /* ,
 367       fAttr(attr),
 368       fAttrValue(newValue) */
 369   {
 370   }
 371   virtual UNumberFormat* initFmt() {
 372     UNumberFormat *fmt = NumTest::initFmt();
 373     //unum_setAttribute(fmt, fAttr,fAttrValue);
 374     return fmt;
 375   }
 376 };
 377
 378 #define DO_NOXNumTest(p,n,x) { NOXNumTest t(p,n,x,__FILE__,__LINE__); runTestOn(t); }
 379
 380 #define DO_TripleNumTest(p,n,x) DO_AttrNumTest(p,n,x,UNUM_PARSE_ALL_INPUT,UNUM_YES) \
 381                                 DO_AttrNumTest(p,n,x,UNUM_PARSE_ALL_INPUT,UNUM_NO) \
 382                                 DO_AttrNumTest(p,n,x,UNUM_PARSE_ALL_INPUT,UNUM_MAYBE)
 383
 384
 385 class NumFmtTest : public HowExpensiveTest {
 386 private:
 387   double fExpect;
 388   UNumberFormat *fFmt;
 389   UnicodeString fPat;
 390   UnicodeString fString;
 391   const UChar *fStr;
 392   int32_t fLen;
 393   const char *fFile;
 394   int fLine;
 395   const char *fCPat;
 396   const char *fCStr;
 397   char name[100];
 398 public:
 399   virtual const char *getName() {
 400     if(name[0]==0) {
 401       sprintf(name,"%s:p=|%s|,str=|%s|",getClassName(),fCPat,fCStr);
 402     }
 403     return name;
 404   }
 405 protected:
 406   virtual UNumberFormat* initFmt() {
 407     return unum_open(UNUM_PATTERN_DECIMAL, fPat.getTerminatedBuffer(), -1, TEST_LOCALE, 0, &setupStatus);
 408   }
 409   virtual const char *getClassName() {
 410     return "NumFmtTest";
 411   }
 412 public:
 413   NumFmtTest(const char *pat, const char *num, double expect, const char *FILE, int LINE)
 414     : HowExpensiveTest("(n/a)",FILE, LINE),
 415       fExpect(expect),
 416       fFmt(0),
 417       fPat(pat, -1, US_INV),
 418       fString(num,-1,US_INV),
 419       fStr(fString.getTerminatedBuffer()),
 420       fLen(u_strlen(fStr)),
 421       fFile(FILE),
 422       fLine(LINE),
 423       fCPat(pat),
 424       fCStr(num)
 425   {
 426     name[0]=0;
 427   }
 428   void warmup() {
 429     fFmt = initFmt();
 430     UChar buf[100];
 431     if(U_SUCCESS(setupStatus)) {
 432       int32_t trial = unum_formatDouble(fFmt,fExpect, buf, 100, NULL, &setupStatus);
 433       if(!U_SUCCESS(setupStatus)
 434          || trial!=fLen
 435          ||trial<=0
 436          || u_strncmp(fStr,buf,trial)  ) {
 437         char strBuf[200];
 438         u_strToUTF8(strBuf,200,NULL,buf,trial+1,&setupStatus);
 439         printf("%s:%d: warmup() %s got %s expected %s, err %s\n",
 440                fFile,fLine,getName(),strBuf,fCStr, u_errorName(setupStatus));
 441         setupStatus = U_INTERNAL_PROGRAM_ERROR;
 442       }
 443     }
 444   }
 445   int32_t run() {
 446     int32_t trial;
 447     int i;
 448     UChar buf[100];
 449     if(U_SUCCESS(setupStatus)) {
 450       for(i=0;i<U_LOTS_OF_TIMES;i++){
 451         trial = unum_formatDouble(fFmt,fExpect, buf, 100, NULL, &setupStatus);
 452       }
 453     }
 454     return i;
 455   }
 456   virtual ~NumFmtTest(){}
 457 };
 458
 459 #define DO_NumFmtTest(p,n,x) { NumFmtTest t(p,n,x,__FILE__,__LINE__); runTestOn(t); }
 460
 461 class NumFmtInt64Test : public HowExpensiveTest {
 462 public:
 463   enum EMode {
 464     kDefault,
 465     kPattern,
 466     kApplyPattern,
 467     kGroupOff,
 468     kApplyGroupOff
 469   };
 470 private:
 471   EMode   fMode;
 472   int64_t fExpect;
 473   UNumberFormat *fFmt;
 474   UnicodeString fPat;
 475   UnicodeString fString;
 476   const UChar *fStr;
 477   int32_t fLen;
 478   const char *fFile;
 479   int fLine;
 480   const char *fCPat;
 481   const char *fCStr;
 482   char name[100];
 483 public:
 484   virtual const char *getName() {
 485     if(name[0]==0) {
 486       sprintf(name,"%s:p=|%s|,str=|%s|",getClassName(),fCPat,fCStr);
 487     }
 488     return name;
 489   }
 490 protected:
 491   virtual UNumberFormat* initFmt() {
 492     switch(fMode) {
 493     case kPattern:
 494       return unum_open(UNUM_PATTERN_DECIMAL, fPat.getTerminatedBuffer(), -1, TEST_LOCALE, 0, &setupStatus);
 495     case kApplyPattern:
 496       {
 497         UNumberFormat *fmt = unum_open(UNUM_DECIMAL, NULL, -1, TEST_LOCALE, 0, &setupStatus);
 498         unum_applyPattern(fmt, FALSE, fPat.getTerminatedBuffer(), -1, NULL, &setupStatus);
 499         return fmt;
 500       }
 501     case kGroupOff:
 502       {
 503         UNumberFormat *fmt = unum_open(UNUM_PATTERN_DECIMAL, fPat.getTerminatedBuffer(), -1, TEST_LOCALE, 0, &setupStatus);
 504         unum_setAttribute(fmt, UNUM_GROUPING_USED, UNUM_NO);
 505         return fmt;
 506       }
 507     case kApplyGroupOff:
 508       {
 509         UNumberFormat *fmt = unum_open(UNUM_DECIMAL, NULL, -1, TEST_LOCALE, 0, &setupStatus);
 510         unum_applyPattern(fmt, FALSE, fPat.getTerminatedBuffer(), -1, NULL, &setupStatus);
 511         unum_setAttribute(fmt, UNUM_GROUPING_USED, UNUM_NO);
 512         return fmt;
 513       }
 514     default:
 515     case kDefault:
 516       return unum_open(UNUM_DEFAULT, NULL, -1, TEST_LOCALE, 0, &setupStatus);
 517     }
 518   }
 519   virtual const char *getClassName() {
 520     switch(fMode) {
 521     case EMode::kDefault:
 522       return "NumFmtInt64Test (default)";
 523     case EMode::kPattern:
 524       return "NumFmtInt64Test (pattern)";
 525     case EMode::kApplyPattern:
 526       return "NumFmtInt64Test (applypattern)";
 527     case EMode::kGroupOff:
 528       return "NumFmtInt64Test (pattern, group=off)";
 529     case EMode::kApplyGroupOff:
 530       return "NumFmtInt64Test (applypattern, group=off)";
 531     default:
 532       return "NumFmtInt64Test (? ? ?)";
 533     }
 534   }
 535 public:
 536   NumFmtInt64Test(const char *pat, const char *num, int64_t expect, const char *FILE, int LINE, EMode mode)
 537     : HowExpensiveTest("(n/a)",FILE, LINE),
 538       fMode(mode),
 539       fExpect(expect),
 540       fFmt(0),
 541       fPat(pat, -1, US_INV),
 542       fString(num,-1,US_INV),
 543       fStr(fString.getTerminatedBuffer()),
 544       fLen(u_strlen(fStr)),
 545       fFile(FILE),
 546       fLine(LINE),
 547       fCPat(pat),
 548       fCStr(num)
 549   {
 550     name[0]=0;
 551   }
 552   void warmup() {
 553     fFmt = initFmt();
 554     UChar buf[100];
 555     if(U_SUCCESS(setupStatus)) {
 556       int32_t trial = unum_formatInt64(fFmt,fExpect, buf, 100, NULL, &setupStatus);
 557       if(!U_SUCCESS(setupStatus)
 558          || trial!=fLen
 559          ||trial<=0
 560          || u_strncmp(fStr,buf,trial)  ) {
 561         char strBuf[200];
 562         u_strToUTF8(strBuf,200,NULL,buf,trial+1,&setupStatus);
 563         printf("%s:%d: warmup() %s got %s (len %d) expected %s (len %d), err %s\n",
 564                fFile,fLine,getName(),strBuf,trial,fCStr,fLen, u_errorName(setupStatus));
 565         setupStatus = U_INTERNAL_PROGRAM_ERROR;
 566       }
 567     }
 568   }
 569   int32_t run() {
 570     int32_t trial;
 571     int i;
 572     UChar buf[100];
 573     if(U_SUCCESS(setupStatus)) {
 574       for(i=0;i<U_LOTS_OF_TIMES;i++){
 575         trial = unum_formatInt64(fFmt,fExpect, buf, 100, NULL, &setupStatus);
 576       }
 577     }
 578     return i;
 579   }
 580   virtual ~NumFmtInt64Test(){}
 581 };
 582
 583 /**
 584  * unum_open .. with pattern, == new DecimalFormat(pattern)
 585  */
 586 #define DO_NumFmtInt64Test(p,n,x) { NumFmtInt64Test t(p,n,x,__FILE__,__LINE__,NumFmtInt64Test::EMode::kPattern); runTestOn(t); }
 587 /**
 588  * unum_open(UNUM_DECIMAL), then
 589  */
 590 #define DO_NumFmtInt64Test_apply(p,n,x) { NumFmtInt64Test t(p,n,x,__FILE__,__LINE__,NumFmtInt64Test::EMode::kApplyPattern); runTestOn(t); }
 591
 592 #define DO_NumFmtInt64Test_default(p,n,x) { NumFmtInt64Test t(p,n,x,__FILE__,__LINE__,NumFmtInt64Test::EMode::kDefault); runTestOn(t); }
 593 #define DO_NumFmtInt64Test_gr0(p,n,x) { NumFmtInt64Test t(p,n,x,__FILE__,__LINE__,NumFmtInt64Test::EMode::kGroupOff); runTestOn(t); }
 594 #define DO_NumFmtInt64Test_applygr0(p,n,x) { NumFmtInt64Test t(p,n,x,__FILE__,__LINE__,NumFmtInt64Test::EMode::kApplyGroupOff); runTestOn(t); }
 595
 596
 597 class NumFmtStringPieceTest : public HowExpensiveTest {
 598 private:
 599   const StringPiece &fExpect;
 600   UNumberFormat *fFmt;
 601   UnicodeString fPat;
 602   UnicodeString fString;
 603   const UChar *fStr;
 604   int32_t fLen;
 605   const char *fFile;
 606   int fLine;
 607   const char *fCPat;
 608   const char *fCStr;
 609   char name[100];
 610 public:
 611   virtual const char *getName() {
 612     if(name[0]==0) {
 613       sprintf(name,"%s:p=|%s|,str=|%s|,sp=|%s|",getClassName(),fCPat,fCStr, fExpect.data());
 614     }
 615     return name;
 616   }
 617 protected:
 618   virtual UNumberFormat* initFmt() {
 619     DecimalFormat *d = new DecimalFormat(setupStatus);
 620     UParseError pe;
 621     d->applyPattern(fPat, pe, setupStatus);
 622     return (UNumberFormat*) d;
 623   }
 624   virtual const char *getClassName() {
 625     return "NumFmtStringPieceTest";
 626   }
 627 public:
 628   NumFmtStringPieceTest(const char *pat, const char *num, const StringPiece& expect, const char *FILE, int LINE)
 629     : HowExpensiveTest("(n/a)",FILE, LINE),
 630       fExpect(expect),
 631       fFmt(0),
 632       fPat(pat, -1, US_INV),
 633       fString(num,-1,US_INV),
 634       fStr(fString.getTerminatedBuffer()),
 635       fLen(u_strlen(fStr)),
 636       fFile(FILE),
 637       fLine(LINE),
 638       fCPat(pat),
 639       fCStr(num)
 640   {
 641     name[0]=0;
 642   }
 643   void warmup() {
 644     fFmt = initFmt();
 645     UnicodeString buf;
 646     if(U_SUCCESS(setupStatus)) {
 647       buf.remove();
 648       ((const DecimalFormat*)fFmt)->format(fExpect, buf, NULL, setupStatus);
 649       if(!U_SUCCESS(setupStatus)
 650          || fString!=buf
 651          ) {
 652         char strBuf[200];
 653         u_strToUTF8(strBuf,200,NULL,buf.getTerminatedBuffer(),buf.length()+1,&setupStatus);
 654         printf("%s:%d: warmup() %s got %s (len %d) expected %s (len %d), err %s\n",
 655                fFile,fLine,getName(),strBuf,buf.length(),fCStr,fLen, u_errorName(setupStatus));
 656         setupStatus = U_INTERNAL_PROGRAM_ERROR;
 657       }
 658     }
 659   }
 660
 661   int32_t run() {
 662 #if U_DEBUG
 663     int32_t trial;
 664 #endif
 665     int i=0;
 666     UnicodeString buf;
 667     if(U_SUCCESS(setupStatus)) {
 668       for(i=0;i<U_LOTS_OF_TIMES;i++){
 669         buf.remove();
 670         ((const DecimalFormat*)fFmt)->format(fExpect, buf, NULL, setupStatus);
 671       }
 672     }
 673     return i;
 674   }
 675   virtual ~NumFmtStringPieceTest(){}
 676 };
 677
 678 #define DO_NumFmtStringPieceTest(p,n,x) { NumFmtStringPieceTest t(p,n,x,__FILE__,__LINE__); runTestOn(t); }
 679
 680 // TODO: move, scope.
 681 static UChar pattern[] = { 0x23 }; // '#'
 682 static UChar strdot[] = { '2', '.', '0', 0 };
 683 static UChar strspc[] = { '2', ' ', 0 };
 684 static UChar strgrp[] = {'2',',','2','2','2', 0 };
 685 static UChar strbeng[] = {0x09E8,0x09E8,0x09E8,0x09E8, 0 };
 686
 687 UNumberFormat *NumParseTest_fmt;
 688
 689 // TODO: de-uglify.
 690 QuickTest(NumParseTest,{    static UChar pattern[] = { 0x23 };    NumParseTest_fmt = unum_open(UNUM_PATTERN_DECIMAL,         pattern,                    1,                    TEST_LOCALE,                    0,                    &setupStatus);  },{    int32_t i;    static UChar str[] = { 0x31 };double val;    for(i=0;i<U_LOTS_OF_TIMES;i++) {      val=unum_parse(NumParseTest_fmt,str,1,NULL,&setupStatus);    }    return i;  },{unum_close(NumParseTest_fmt);})
 691
 692 QuickTest(NumParseTestdot,{    static UChar pattern[] = { 0x23 };    NumParseTest_fmt = unum_open(UNUM_PATTERN_DECIMAL,         pattern,                    1,                    TEST_LOCALE,                    0,                    &setupStatus);  },{    int32_t i;  double val;    for(i=0;i<U_LOTS_OF_TIMES;i++) {      val=unum_parse(NumParseTest_fmt,strdot,1,NULL,&setupStatus);    }    return i;  },{unum_close(NumParseTest_fmt);})
 693 QuickTest(NumParseTestspc,{    static UChar pattern[] = { 0x23 };    NumParseTest_fmt = unum_open(UNUM_PATTERN_DECIMAL,         pattern,                    1,                    TEST_LOCALE,                    0,                    &setupStatus);  },{    int32_t i;    double val;    for(i=0;i<U_LOTS_OF_TIMES;i++) {      val=unum_parse(NumParseTest_fmt,strspc,1,NULL,&setupStatus);    }    return i;  },{unum_close(NumParseTest_fmt);})
 694 QuickTest(NumParseTestgrp,{    static UChar pattern[] = { 0x23 };    NumParseTest_fmt = unum_open(UNUM_PATTERN_DECIMAL,         pattern,                    1,                    TEST_LOCALE,                    0,                    &setupStatus);  },{    int32_t i;    double val;    for(i=0;i<U_LOTS_OF_TIMES;i++) {      val=unum_parse(NumParseTest_fmt,strgrp,-1,NULL,&setupStatus);    }    return i;  },{unum_close(NumParseTest_fmt);})
 695
 696 QuickTest(NumParseTestbeng,{    static UChar pattern[] = { 0x23 };    NumParseTest_fmt = unum_open(UNUM_PATTERN_DECIMAL,         pattern,                    1,                    TEST_LOCALE,                    0,                    &setupStatus);  },{    int32_t i;    double val;    for(i=0;i<U_LOTS_OF_TIMES;i++) {      val=unum_parse(NumParseTest_fmt,strbeng,-1,NULL,&setupStatus);    }    return i;  },{unum_close(NumParseTest_fmt);})
 697
 698 UDateFormat *DateFormatTest_fmt = NULL;
 699 UDate sometime = 100000000.0;
 700 UChar onekbuf[1024];
 701 const int32_t onekbuf_len = sizeof(onekbuf)/sizeof(onekbuf[0]);
 702
 703
 704 QuickTest(DateFormatTestBasic, \
 705           { \
 706             DateFormatTest_fmt = udat_open(UDAT_DEFAULT, UDAT_DEFAULT, NULL, NULL, -1, NULL, -1, &setupStatus); \
 707           }, \
 708           { \
 709             int i; \
 710             for(i=0;i<U_LOTS_OF_TIMES;i++)  \
 711             { \
 712               udat_format(DateFormatTest_fmt, sometime, onekbuf, onekbuf_len, NULL, &setupStatus); \
 713             } \
 714             return i; \
 715           }, \
 716           { \
 717             udat_close(DateFormatTest_fmt); \
 718           } \
 719       )
 720
 721
 722 QuickTest(NullTest,{},{int j=U_LOTS_OF_TIMES;while(--j);return U_LOTS_OF_TIMES;},{})
 723
 724 #if 0
 725 #include <time.h>
 726
 727 QuickTest(RandomTest,{},{timespec ts; ts.tv_sec=rand()%4; int j=U_LOTS_OF_TIMES;while(--j) { ts.tv_nsec=100000+(rand()%10000)*1000000; nanosleep(&ts,NULL); return j;} return U_LOTS_OF_TIMES;},{})
 728 #endif
 729
 730 OpenCloseTest(pattern,unum,open,{},(UNUM_PATTERN_DECIMAL,pattern,1,TEST_LOCALE,0,&setupStatus),{})
 731 OpenCloseTest(default,unum,open,{},(UNUM_DEFAULT,NULL,-1,TEST_LOCALE,0,&setupStatus),{})
 732 #if !UCONFIG_NO_CONVERSION
 733 #include "unicode/ucnv.h"
 734 OpenCloseTest(gb18030,ucnv,open,{},("gb18030",&setupStatus),{})
 735 #endif
 736 #include "unicode/ures.h"
 737 OpenCloseTest(root,ures,open,{},(NULL,"root",&setupStatus),{})
 738
 739 void runTests() {
 740   {
 741     SieveTest t;
 742     runTestOn(t);
 743   }
 744 #if 0
 745   {
 746     RandomTest t;
 747     runTestOn(t);
 748   }
 749 #endif
 750   {
 751     NullTest t;
 752     runTestOn(t);
 753   }
 754
 755 #ifndef SKIP_DATEFMT_TESTS
 756   {
 757     DateFormatTestBasic t;
 758     runTestOn(t);
 759   }
 760 #endif
 761
 762 #ifndef SKIP_NUMPARSE_TESTS
 763   {
 764     // parse tests
 765
 766     DO_NumTest("#","0",0.0);
 767     DO_NumTest("#","2.0",2.0);
 768     DO_NumTest("#","2 ",2);
 769     DO_NumTest("#","-2 ",-2);
 770     DO_NumTest("+#","+2",2);
 771     DO_NumTest("#,###.0","2222.0",2222.0);
 772     DO_NumTest("#.0","1.000000000000000000000000000000000000000000000000000000000000000000000000000000",1.0);
 773     DO_NumTest("#","123456",123456);
 774
 775     // attr
 776 #ifdef HAVE_UNUM_MAYBE
 777     DO_AttrNumTest("#","0",0.0,UNUM_PARSE_ALL_INPUT,UNUM_YES);
 778     DO_AttrNumTest("#","0",0.0,UNUM_PARSE_ALL_INPUT,UNUM_NO);
 779     DO_AttrNumTest("#","0",0.0,UNUM_PARSE_ALL_INPUT,UNUM_MAYBE);
 780     DO_TripleNumTest("#","2.0",2.0);
 781     DO_AttrNumTest("#.0","1.000000000000000000000000000000000000000000000000000000000000000000000000000000",1.0,UNUM_PARSE_ALL_INPUT,UNUM_NO);
 782 #endif
 783
 784
 785     //  {    NumParseTestgrp t;    runTestOn(t);  }
 786     {    NumParseTestbeng t;    runTestOn(t);  }
 787
 788   }
 789 #endif
 790
 791 #ifndef SKIP_NUMFORMAT_TESTS
 792   // format tests
 793   {
 794
 795     DO_NumFmtInt64Test("0000","0001",1);
 796     DO_NumFmtInt64Test("0000","0000",0);
 797     StringPiece sp3456("3456");
 798     DO_NumFmtStringPieceTest("0000","3456",sp3456);
 799     DO_NumFmtStringPieceTest("#","3456",sp3456);
 800     StringPiece sp3("3");
 801     DO_NumFmtStringPieceTest("0000","0003",sp3);
 802     DO_NumFmtStringPieceTest("#","3",sp3);
 803     StringPiece spn3("-3");
 804     DO_NumFmtStringPieceTest("0000","-0003",spn3);
 805     DO_NumFmtStringPieceTest("#","-3",spn3);
 806     StringPiece spPI("123.456");
 807     DO_NumFmtStringPieceTest("#.0000","123.4560",spPI);
 808     DO_NumFmtStringPieceTest("#.00","123.46",spPI);
 809
 810     DO_NumFmtTest("#","0",0.0);
 811     DO_NumFmtTest("#","12345",12345);
 812     DO_NumFmtTest("#","-2",-2);
 813     DO_NumFmtTest("+#","+2",2);
 814
 815     DO_NumFmtInt64Test("#","-682",-682);
 816     DO_NumFmtInt64Test("#","0",0);
 817     DO_NumFmtInt64Test("#","12345",12345);
 818     DO_NumFmtInt64Test("#,###","12,345",12345);
 819     DO_NumFmtInt64Test("#","1234",1234);
 820     DO_NumFmtInt64Test("#","123",123);
 821     DO_NumFmtInt64Test("#,###","123",123);
 822     DO_NumFmtInt64Test_apply("#","123",123);
 823     DO_NumFmtInt64Test_apply("#","12345",12345);
 824     DO_NumFmtInt64Test_apply("#,###","123",123);
 825     DO_NumFmtInt64Test_apply("#,###","12,345",12345);
 826     DO_NumFmtInt64Test_default("","123",123);
 827     DO_NumFmtInt64Test_default("","12,345",12345);
 828     DO_NumFmtInt64Test_applygr0("#","123",123);
 829     DO_NumFmtInt64Test_applygr0("#","12345",12345);
 830     DO_NumFmtInt64Test_applygr0("#,###","123",123);
 831     DO_NumFmtInt64Test_applygr0("#,###","12345",12345);
 832     DO_NumFmtInt64Test_gr0("#","123",123);
 833     DO_NumFmtInt64Test_gr0("#","12345",12345);
 834     DO_NumFmtInt64Test_gr0("#,###","123",123);
 835     DO_NumFmtInt64Test_gr0("#,###","12345",12345);
 836     DO_NumFmtInt64Test("#","-2",-2);
 837     DO_NumFmtInt64Test("+#","+2",2);
 838   }
 839
 840 #ifndef SKIP_NUM_OPEN_TEST
 841   {
 842     Test_unum_opendefault t;
 843     runTestOn(t);
 844   }
 845   {
 846     Test_unum_openpattern t;
 847     runTestOn(t);
 848   }
 849 #endif
 850
 851 #endif /* skip numformat tests */
 852 #if !UCONFIG_NO_CONVERSION
 853   {
 854     Test_ucnv_opengb18030 t;
 855     runTestOn(t);
 856   }
 857 #endif
 858   {
 859     Test_ures_openroot t;
 860     runTestOn(t);
 861   }
 862
 863   if(testhit==0) {
 864     fprintf(stderr, "ERROR: no tests matched.\n");
 865   }
 866 }