icuSources/test/perf/howExpensiveIs/howExpensiveIs.cpp

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