source/tools/ctestfw/ctest.c

   1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 ********************************************************************************
   5 *
   6 *   Copyright (C) 1996-2014, International Business Machines
   7 *   Corporation and others.  All Rights Reserved.
   8 *
   9 ********************************************************************************
  10 */
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <assert.h>
  15 #include <stdarg.h>
  16 #include <ctype.h>
  17
  18 #include "unicode/utrace.h"
  19 #include "unicode/uclean.h"
  20 #include "putilimp.h"
  21 #include "udbgutil.h"
  22
  23 /* NOTES:
  24    3/20/1999 srl - strncpy called w/o setting nulls at the end
  25  */
  26
  27 #define MAXTESTNAME 128
  28 #define MAXTESTS  512
  29 #define MAX_TEST_LOG 4096
  30
  31 /**
  32  *  How may columns to indent the 'OK' markers.
  33  */
  34 #define FLAG_INDENT 45
  35 /**
  36  *   How many lines of scrollage can go by before we need to remind the user what the test is.
  37  */
  38 #define PAGE_SIZE_LIMIT 25
  39
  40 #ifndef SHOW_TIMES
  41 #define SHOW_TIMES 1
  42 #endif
  43
  44 struct TestNode
  45 {
  46   void (*test)(void);
  47   struct TestNode* sibling;
  48   struct TestNode* child;
  49   char name[1]; /* This is dynamically allocated off the end with malloc. */
  50 };
  51
  52
  53 static const struct TestNode* currentTest;
  54
  55 typedef enum { RUNTESTS, SHOWTESTS } TestMode;
  56 #define TEST_SEPARATOR '/'
  57
  58 #ifndef C_TEST_IMPL
  59 #define C_TEST_IMPL
  60 #endif
  61
  62 #include "unicode/ctest.h"
  63
  64 static char ERROR_LOG[MAX_TEST_LOG][MAXTESTNAME];
  65
  66 /* Local prototypes */
  67 static TestNode* addTestNode( TestNode *root, const char *name );
  68
  69 static TestNode *createTestNode(const char* name, int32_t nameLen);
  70
  71 static int strncmp_nullcheck( const char* s1,
  72                   const char* s2,
  73                   int n );
  74
  75 static void getNextLevel( const char* name,
  76               int* nameLen,
  77               const char** nextName );
  78
  79 static void iterateTestsWithLevel( const TestNode *root, int depth,
  80                    const TestNode** nodeList,
  81                    TestMode mode);
  82
  83 static void help ( const char *argv0 );
  84
  85 /**
  86  * Do the work of logging an error. Doesn't increase the error count.
  87  *
  88  * @prefix optional prefix prepended to message, or NULL.
  89  * @param pattern printf style pattern
  90  * @param ap vprintf style arg list
  91  */
  92 static void vlog_err(const char *prefix, const char *pattern, va_list ap);
  93 static void vlog_verbose(const char *prefix, const char *pattern, va_list ap);
  94 static UBool vlog_knownIssue(const char *ticket, const char *pattern, va_list ap);
  95
  96 /**
  97  * Log test structure, with indent
  98  * @param pattern printf pattern
  99  */
 100 static void log_testinfo_i(const char *pattern, ...);
 101
 102 /**
 103  * Log test structure, NO indent
 104  * @param pattern printf pattern
 105  */
 106 static void log_testinfo(const char *pattern, ...);
 107
 108 /* If we need to make the framework multi-thread safe
 109    we need to pass around the following vars
 110 */
 111 static int ERRONEOUS_FUNCTION_COUNT = 0;
 112 static int ERROR_COUNT = 0; /* Count of errors from all tests. */
 113 static int ONE_ERROR = 0; /* were there any other errors? */
 114 static int DATA_ERROR_COUNT = 0; /* count of data related errors or warnings */
 115 static int INDENT_LEVEL = 0;
 116 static UBool NO_KNOWN = FALSE;
 117 static void *knownList = NULL;
 118 static char gTestName[1024] = "";
 119 static UBool ON_LINE = FALSE; /* are we on the top line with our test name? */
 120 static UBool HANGING_OUTPUT = FALSE; /* did the user leave us without a trailing \n ? */
 121 static int GLOBAL_PRINT_COUNT = 0; /* global count of printouts */
 122 int REPEAT_TESTS_INIT = 0; /* Was REPEAT_TESTS initialized? */
 123 int REPEAT_TESTS = 1; /* Number of times to run the test */
 124 int VERBOSITY = 0; /* be No-verbose by default */
 125 int ERR_MSG =1; /* error messages will be displayed by default*/
 126 int QUICK = 1;  /* Skip some of the slower tests? */
 127 int WARN_ON_MISSING_DATA = 0; /* Reduce data errs to warnings? */
 128 UTraceLevel ICU_TRACE = UTRACE_OFF;  /* ICU tracing level */
 129 size_t MINIMUM_MEMORY_SIZE_FAILURE = (size_t)-1; /* Minimum library memory allocation window that will fail. */
 130 size_t MAXIMUM_MEMORY_SIZE_FAILURE = (size_t)-1; /* Maximum library memory allocation window that will fail. */
 131 static const char *ARGV_0 = "[ALL]";
 132 static const char *XML_FILE_NAME=NULL;
 133 static char XML_PREFIX[256];
 134 static const char *SUMMARY_FILE = NULL;
 135 FILE *XML_FILE = NULL;
 136 /*-------------------------------------------*/
 137
 138 /* strncmp that also makes sure there's a \0 at s2[0] */
 139 static int strncmp_nullcheck( const char* s1,
 140                const char* s2,
 141                int n )
 142 {
 143     if (((int)strlen(s2) >= n) && s2[n] != 0) {
 144         return 3; /* null check fails */
 145     }
 146     else {
 147         return strncmp ( s1, s2, n );
 148     }
 149 }
 150
 151 static void getNextLevel( const char* name,
 152            int* nameLen,
 153            const char** nextName )
 154 {
 155     /* Get the next component of the name */
 156     *nextName = strchr(name, TEST_SEPARATOR);
 157
 158     if( *nextName != 0 )
 159     {
 160         char n[255];
 161         *nameLen = (int)((*nextName) - name);
 162         (*nextName)++; /* skip '/' */
 163         strncpy(n, name, *nameLen);
 164         n[*nameLen] = 0;
 165         /*printf("->%s-< [%d] -> [%s]\n", name, *nameLen, *nextName);*/
 166     }
 167     else {
 168         *nameLen = (int)strlen(name);
 169     }
 170 }
 171
 172 static TestNode *createTestNode(const char* name, int32_t nameLen)
 173 {
 174     TestNode *newNode;
 175
 176     newNode = (TestNode*)malloc(sizeof(TestNode) + (nameLen + 1));
 177
 178     newNode->test = NULL;
 179     newNode->sibling = NULL;
 180     newNode->child = NULL;
 181
 182     strncpy( newNode->name, name, nameLen );
 183     newNode->name[nameLen] = 0;
 184
 185     return  newNode;
 186 }
 187
 188 void T_CTEST_EXPORT2
 189 cleanUpTestTree(TestNode *tn)
 190 {
 191     if(tn->child != NULL) {
 192         cleanUpTestTree(tn->child);
 193     }
 194     if(tn->sibling != NULL) {
 195         cleanUpTestTree(tn->sibling);
 196     }
 197
 198     free(tn);
 199
 200 }
 201
 202
 203 void T_CTEST_EXPORT2
 204 addTest(TestNode** root,
 205         TestFunctionPtr test,
 206         const char* name )
 207 {
 208     TestNode *newNode;
 209
 210     /*if this is the first Test created*/
 211     if (*root == NULL)
 212         *root = createTestNode("", 0);
 213
 214     newNode = addTestNode( *root, name );
 215     assert(newNode != 0 );
 216     /*  printf("addTest: nreName = %s\n", newNode->name );*/
 217
 218     newNode->test = test;
 219 }
 220
 221 /* non recursive insert function */
 222 static TestNode *addTestNode ( TestNode *root, const char *name )
 223 {
 224     const char* nextName;
 225     TestNode *nextNode, *curNode;
 226     int nameLen; /* length of current 'name' */
 227
 228     /* remove leading slash */
 229     if ( *name == TEST_SEPARATOR )
 230         name++;
 231
 232     curNode = root;
 233
 234     for(;;)
 235     {
 236         /* Start with the next child */
 237         nextNode = curNode->child;
 238
 239         getNextLevel ( name, &nameLen, &nextName );
 240
 241         /*      printf("* %s\n", name );*/
 242
 243         /* if nextNode is already null, then curNode has no children
 244         -- add them */
 245         if( nextNode == NULL )
 246         {
 247             /* Add all children of the node */
 248             do
 249             {
 250                 /* Get the next component of the name */
 251                 getNextLevel(name, &nameLen, &nextName);
 252
 253                 /* update curName to have the next name segment */
 254                 curNode->child = createTestNode(name, nameLen);
 255                 /* printf("*** added %s\n", curNode->child->name );*/
 256                 curNode = curNode->child;
 257                 name = nextName;
 258             }
 259             while( name != NULL );
 260
 261             return curNode;
 262         }
 263
 264         /* Search across for the name */
 265         while (strncmp_nullcheck ( name, nextNode->name, nameLen) != 0 )
 266         {
 267             curNode = nextNode;
 268             nextNode = nextNode -> sibling;
 269
 270             if ( nextNode == NULL )
 271             {
 272                 /* Did not find 'name' on this level. */
 273                 nextNode = createTestNode(name, nameLen);
 274                 curNode->sibling = nextNode;
 275                 break;
 276             }
 277         }
 278
 279         /* nextNode matches 'name' */
 280
 281         if (nextName == NULL) /* end of the line */
 282         {
 283             return nextNode;
 284         }
 285
 286         /* Loop again with the next item */
 287         name = nextName;
 288         curNode = nextNode;
 289     }
 290 }
 291
 292 /**
 293  * Log the time taken. May not output anything.
 294  * @param deltaTime change in time
 295  */
 296 void T_CTEST_EXPORT2 str_timeDelta(char *str, UDate deltaTime) {
 297   if (deltaTime > 110000.0 ) {
 298     double mins = uprv_floor(deltaTime/60000.0);
 299     sprintf(str, "[(%.0fm %.1fs)]", mins, (deltaTime-(mins*60000.0))/1000.0);
 300   } else if (deltaTime > 1500.0) {
 301     sprintf(str, "((%.1fs))", deltaTime/1000.0);
 302   } else if(deltaTime>900.0) {
 303     sprintf(str, "( %.2fs )", deltaTime/1000.0);
 304   } else if(deltaTime > 5.0) {
 305     sprintf(str, " (%.0fms) ", deltaTime);
 306   } else {
 307     str[0]=0; /* at least terminate it. */
 308   }
 309 }
 310
 311 static void print_timeDelta(UDate deltaTime) {
 312   char str[256];
 313   str_timeDelta(str, deltaTime);
 314   if(str[0]) {
 315     printf("%s", str);
 316   }
 317 }
 318
 319 /**
 320  * Run or list tests (according to mode) in a subtree.
 321  *
 322  * @param root root of the subtree to operate on
 323  * @param depth The depth of this tree (0=root)
 324  * @param nodeList an array of MAXTESTS depth that's used for keeping track of where we are. nodeList[depth] points to the 'parent' at depth depth.
 325  * @param mode what mode we are operating in.
 326  */
 327 static void iterateTestsWithLevel ( const TestNode* root,
 328                  int depth,
 329                  const TestNode** nodeList,
 330                  TestMode mode)
 331 {
 332     int i;
 333
 334     char pathToFunction[MAXTESTNAME] = "";
 335     char separatorString[2] = { TEST_SEPARATOR, '\0'};
 336 #if SHOW_TIMES
 337     UDate allStartTime = -1, allStopTime = -1;
 338 #endif
 339
 340     if(depth<2) {
 341       allStartTime = uprv_getRawUTCtime();
 342     }
 343
 344     if ( root == NULL )
 345         return;
 346
 347     /* record the current root node, and increment depth. */
 348     nodeList[depth++] = root;
 349     /* depth is now the depth of root's children. */
 350
 351     /* Collect the 'path' to the current subtree. */
 352     for ( i=0;i<(depth-1);i++ )
 353     {
 354         strcat(pathToFunction, nodeList[i]->name);
 355         strcat(pathToFunction, separatorString);
 356     }
 357     strcat(pathToFunction, nodeList[i]->name); /* including 'root' */
 358
 359     /* print test name and space. */
 360     INDENT_LEVEL = depth-1;
 361     if(root->name[0]) {
 362         log_testinfo_i("%s ", root->name);
 363     } else {
 364         log_testinfo_i("(%s) ", ARGV_0);
 365     }
 366     ON_LINE = TRUE;  /* we are still on the line with the test name */
 367
 368
 369     if ( (mode == RUNTESTS) &&
 370                 (root->test != NULL))  /* if root is a leaf node, run it */
 371     {
 372         int myERROR_COUNT = ERROR_COUNT;
 373         int myGLOBAL_PRINT_COUNT = GLOBAL_PRINT_COUNT;
 374 #if SHOW_TIMES
 375         UDate startTime, stopTime;
 376         char timeDelta[256];
 377         char timeSeconds[256];
 378 #else
 379         const char timeDelta[] = "(unknown)";
 380         const char timeSeconds[] = "0.000";
 381 #endif
 382         currentTest = root;
 383         INDENT_LEVEL = depth;  /* depth of subitems */
 384         ONE_ERROR=0;
 385         HANGING_OUTPUT=FALSE;
 386 #if SHOW_TIMES
 387         startTime = uprv_getRawUTCtime();
 388 #endif
 389         strcpy(gTestName, pathToFunction);
 390         root->test();   /* PERFORM THE TEST ************************/
 391 #if SHOW_TIMES
 392         stopTime = uprv_getRawUTCtime();
 393 #endif
 394         if(HANGING_OUTPUT) {
 395           log_testinfo("\n");
 396           HANGING_OUTPUT=FALSE;
 397         }
 398         INDENT_LEVEL = depth-1;  /* depth of root */
 399         currentTest = NULL;
 400         if((ONE_ERROR>0)&&(ERROR_COUNT==0)) {
 401           ERROR_COUNT++; /* There was an error without a newline */
 402         }
 403         ONE_ERROR=0;
 404
 405 #if SHOW_TIMES
 406         str_timeDelta(timeDelta, stopTime-startTime);
 407         sprintf(timeSeconds, "%f", (stopTime-startTime)/1000.0);
 408 #endif
 409         ctest_xml_testcase(pathToFunction, pathToFunction, timeSeconds, (myERROR_COUNT!=ERROR_COUNT)?"error":NULL);
 410
 411         if (myERROR_COUNT != ERROR_COUNT) {
 412           log_testinfo_i("} ---[%d ERRORS in %s] ", ERROR_COUNT - myERROR_COUNT, pathToFunction);
 413           strcpy(ERROR_LOG[ERRONEOUS_FUNCTION_COUNT++], pathToFunction);
 414         } else {
 415           if(!ON_LINE) { /* had some output */
 416             int spaces = FLAG_INDENT-(depth-1);
 417             log_testinfo_i("} %*s[OK] ", spaces, "---");
 418             if((GLOBAL_PRINT_COUNT-myGLOBAL_PRINT_COUNT)>PAGE_SIZE_LIMIT) {
 419               log_testinfo(" %s ", pathToFunction); /* in case they forgot. */
 420             }
 421           } else {
 422             /* put -- out at 30 sp. */
 423             int spaces = FLAG_INDENT-(strlen(root->name)+depth);
 424             if(spaces<0) spaces=0;
 425             log_testinfo(" %*s[OK] ", spaces,"---");
 426           }
 427         }
 428
 429 #if SHOW_TIMES
 430         if(timeDelta[0]) printf("%s", timeDelta);
 431 #endif
 432
 433         ON_LINE = TRUE; /* we are back on-line */
 434     }
 435
 436     INDENT_LEVEL = depth-1; /* root */
 437
 438     /* we want these messages to be at 0 indent. so just push the indent level breifly. */
 439     if(mode==SHOWTESTS) {
 440         log_testinfo("---%s%c\n",pathToFunction, nodeList[i]->test?' ':TEST_SEPARATOR );
 441     }
 442
 443     INDENT_LEVEL = depth;
 444
 445     if(root->child) {
 446         int myERROR_COUNT = ERROR_COUNT;
 447         int myGLOBAL_PRINT_COUNT = GLOBAL_PRINT_COUNT;
 448         if(mode!=SHOWTESTS) {
 449                 INDENT_LEVEL=depth-1;
 450                 log_testinfo("{\n");
 451                 INDENT_LEVEL=depth;
 452         }
 453
 454         iterateTestsWithLevel ( root->child, depth, nodeList, mode );
 455
 456         if(mode!=SHOWTESTS) {
 457                 INDENT_LEVEL=depth-1;
 458                 log_testinfo_i("} "); /* TODO:  summarize subtests */
 459                 if((depth>1) && (ERROR_COUNT > myERROR_COUNT)) {
 460                         log_testinfo("[%d %s in %s] ", ERROR_COUNT-myERROR_COUNT, (ERROR_COUNT-myERROR_COUNT)==1?"error":"errors", pathToFunction);
 461                 } else if((GLOBAL_PRINT_COUNT-myGLOBAL_PRINT_COUNT)>PAGE_SIZE_LIMIT || (depth<1)) {
 462                   if(pathToFunction[0]) {
 463                     log_testinfo(" %s ", pathToFunction); /* in case they forgot. */
 464                   } else {
 465                     log_testinfo(" / (%s) ", ARGV_0);
 466                   }
 467                 }
 468
 469                 ON_LINE=TRUE;
 470         }
 471         }
 472     depth--;
 473
 474 #if SHOW_TIMES
 475     if(depth<2) {
 476       allStopTime = uprv_getRawUTCtime();
 477       print_timeDelta(allStopTime-allStartTime);
 478     }
 479 #endif
 480
 481     if(mode!=SHOWTESTS && ON_LINE) {
 482         log_testinfo("\n");
 483     }
 484
 485     if ( depth != 0 ) { /* DO NOT iterate over siblings of the root. TODO: why not? */
 486         iterateTestsWithLevel ( root->sibling, depth, nodeList, mode );
 487     }
 488 }
 489
 490
 491
 492 void T_CTEST_EXPORT2
 493 showTests ( const TestNode *root )
 494 {
 495     /* make up one for them */
 496     const TestNode *nodeList[MAXTESTS];
 497
 498     if (root == NULL)
 499         log_err("TEST CAN'T BE FOUND!");
 500
 501     iterateTestsWithLevel ( root, 0, nodeList, SHOWTESTS );
 502
 503 }
 504
 505 void T_CTEST_EXPORT2
 506 runTests ( const TestNode *root )
 507 {
 508     int i;
 509     const TestNode *nodeList[MAXTESTS];
 510     /* make up one for them */
 511
 512
 513     if (root == NULL)
 514         log_err("TEST CAN'T BE FOUND!\n");
 515
 516     ERRONEOUS_FUNCTION_COUNT = ERROR_COUNT = 0;
 517     iterateTestsWithLevel ( root, 0, nodeList, RUNTESTS );
 518
 519     /*print out result summary*/
 520
 521     ON_LINE=FALSE; /* just in case */
 522
 523     if(knownList != NULL) {
 524       if( udbg_knownIssue_print(knownList) ) {
 525         fprintf(stdout, "(To run suppressed tests, use the -K option.) \n\n");
 526       }
 527       udbg_knownIssue_close(knownList);
 528       knownList = NULL;
 529     }
 530
 531     if (ERROR_COUNT)
 532     {
 533         fprintf(stdout,"\nSUMMARY:\n");
 534         fflush(stdout);
 535         fprintf(stdout,"******* [Total error count:\t%d]\n", ERROR_COUNT);
 536         fflush(stdout);
 537         fprintf(stdout, " Errors in\n");
 538         for (i=0;i < ERRONEOUS_FUNCTION_COUNT; i++)
 539             fprintf(stdout, "[%s]\n",ERROR_LOG[i]);
 540         if(SUMMARY_FILE != NULL) {
 541           FILE *summf = fopen(SUMMARY_FILE, "w");
 542           if(summf!=NULL) {
 543             for (i=0;i < ERRONEOUS_FUNCTION_COUNT; i++)
 544               fprintf(summf, "%s\n",ERROR_LOG[i]);
 545             fclose(summf);
 546           }
 547         }
 548     }
 549     else
 550     {
 551       log_testinfo("\n[All tests passed successfully...]\n");
 552     }
 553
 554     if(DATA_ERROR_COUNT) {
 555       if(WARN_ON_MISSING_DATA==0) {
 556           log_testinfo("\t*Note* some errors are data-loading related. If the data used is not the \n"
 557                  "\tstock ICU data (i.e some have been added or removed), consider using\n"
 558                  "\tthe '-w' option to turn these errors into warnings.\n");
 559       } else {
 560           log_testinfo("\t*WARNING* some data-loading errors were ignored by the -w option.\n");
 561       }
 562     }
 563 }
 564
 565 const char* T_CTEST_EXPORT2
 566 getTestName(void)
 567 {
 568   if(currentTest != NULL) {
 569     return currentTest->name;
 570   } else {
 571     return NULL;
 572   }
 573 }
 574
 575 const TestNode* T_CTEST_EXPORT2
 576 getTest(const TestNode* root, const char* name)
 577 {
 578     const char* nextName;
 579     TestNode *nextNode;
 580     const TestNode* curNode;
 581     int nameLen; /* length of current 'name' */
 582
 583     if (root == NULL) {
 584         log_err("TEST CAN'T BE FOUND!\n");
 585         return NULL;
 586     }
 587     /* remove leading slash */
 588     if ( *name == TEST_SEPARATOR )
 589         name++;
 590
 591     curNode = root;
 592
 593     for(;;)
 594     {
 595         /* Start with the next child */
 596         nextNode = curNode->child;
 597
 598         getNextLevel ( name, &nameLen, &nextName );
 599
 600         /*      printf("* %s\n", name );*/
 601
 602         /* if nextNode is already null, then curNode has no children
 603         -- add them */
 604         if( nextNode == NULL )
 605         {
 606             return NULL;
 607         }
 608
 609         /* Search across for the name */
 610         while (strncmp_nullcheck ( name, nextNode->name, nameLen) != 0 )
 611         {
 612             curNode = nextNode;
 613             nextNode = nextNode -> sibling;
 614
 615             if ( nextNode == NULL )
 616             {
 617                 /* Did not find 'name' on this level. */
 618                 return NULL;
 619             }
 620         }
 621
 622         /* nextNode matches 'name' */
 623
 624         if (nextName == NULL) /* end of the line */
 625         {
 626             return nextNode;
 627         }
 628
 629         /* Loop again with the next item */
 630         name = nextName;
 631         curNode = nextNode;
 632     }
 633 }
 634
 635 /*  =========== io functions ======== */
 636
 637 static void go_offline_with_marker(const char *mrk) {
 638   UBool wasON_LINE = ON_LINE;
 639
 640   if(ON_LINE) {
 641     log_testinfo(" {\n");
 642     ON_LINE=FALSE;
 643   }
 644
 645   if(!HANGING_OUTPUT || wasON_LINE) {
 646     if(mrk != NULL) {
 647       fputs(mrk, stdout);
 648     }
 649   }
 650 }
 651
 652 static void go_offline() {
 653         go_offline_with_marker(NULL);
 654 }
 655
 656 static void go_offline_err() {
 657         go_offline();
 658 }
 659
 660 static void first_line_verbose() {
 661     go_offline_with_marker("v");
 662 }
 663
 664 static void first_line_err() {
 665     go_offline_with_marker("!");
 666 }
 667
 668 static void first_line_info() {
 669     go_offline_with_marker("\"");
 670 }
 671
 672 static void first_line_test() {
 673         fputs(" ", stdout);
 674 }
 675
 676
 677 static void vlog_err(const char *prefix, const char *pattern, va_list ap)
 678 {
 679     if( ERR_MSG == FALSE){
 680         return;
 681     }
 682     fputs("!", stdout); /* col 1 - bang */
 683     fprintf(stdout, "%-*s", INDENT_LEVEL,"" );
 684     if(prefix) {
 685         fputs(prefix, stdout);
 686     }
 687     vfprintf(stdout, pattern, ap);
 688     fflush(stdout);
 689     va_end(ap);
 690     if((*pattern==0) || (pattern[strlen(pattern)-1]!='\n')) {
 691         HANGING_OUTPUT=1;
 692     } else {
 693         HANGING_OUTPUT=0;
 694     }
 695     GLOBAL_PRINT_COUNT++;
 696 }
 697
 698 static UBool vlog_knownIssue(const char *ticket, const char *pattern, va_list ap)
 699 {
 700     char buf[2048];
 701     UBool firstForTicket;
 702     UBool firstForWhere;
 703
 704     if(NO_KNOWN) return FALSE;
 705     if(pattern==NULL) pattern="";
 706
 707     vsprintf(buf, pattern, ap);
 708     knownList = udbg_knownIssue_open(knownList, ticket, gTestName, buf,
 709                                      &firstForTicket, &firstForWhere);
 710
 711     if(firstForTicket || firstForWhere) {
 712       log_info("(Known issue #%s) %s\n", ticket, buf);
 713     } else {
 714       log_verbose("(Known issue #%s) %s\n", ticket, buf);
 715     }
 716
 717     return TRUE;
 718 }
 719
 720
 721 void T_CTEST_EXPORT2
 722 vlog_info(const char *prefix, const char *pattern, va_list ap)
 723 {
 724         first_line_info();
 725     fprintf(stdout, "%-*s", INDENT_LEVEL,"" );
 726     if(prefix) {
 727         fputs(prefix, stdout);
 728     }
 729     vfprintf(stdout, pattern, ap);
 730     fflush(stdout);
 731     va_end(ap);
 732     if((*pattern==0) || (pattern[strlen(pattern)-1]!='\n')) {
 733         HANGING_OUTPUT=1;
 734     } else {
 735         HANGING_OUTPUT=0;
 736     }
 737     GLOBAL_PRINT_COUNT++;
 738 }
 739 /**
 740  * Log test structure, with indent
 741  */
 742 static void log_testinfo_i(const char *pattern, ...)
 743 {
 744     va_list ap;
 745     first_line_test();
 746     fprintf(stdout, "%-*s", INDENT_LEVEL,"" );
 747     va_start(ap, pattern);
 748     vfprintf(stdout, pattern, ap);
 749     fflush(stdout);
 750     va_end(ap);
 751     GLOBAL_PRINT_COUNT++;
 752 }
 753 /**
 754  * Log test structure (no ident)
 755  */
 756 static void log_testinfo(const char *pattern, ...)
 757 {
 758     va_list ap;
 759     va_start(ap, pattern);
 760     first_line_test();
 761     vfprintf(stdout, pattern, ap);
 762     fflush(stdout);
 763     va_end(ap);
 764     GLOBAL_PRINT_COUNT++;
 765 }
 766
 767
 768 static void vlog_verbose(const char *prefix, const char *pattern, va_list ap)
 769 {
 770     if ( VERBOSITY == FALSE )
 771         return;
 772
 773     first_line_verbose();
 774     fprintf(stdout, "%-*s", INDENT_LEVEL,"" );
 775     if(prefix) {
 776         fputs(prefix, stdout);
 777     }
 778     vfprintf(stdout, pattern, ap);
 779     fflush(stdout);
 780     va_end(ap);
 781     GLOBAL_PRINT_COUNT++;
 782     if((*pattern==0) || (pattern[strlen(pattern)-1]!='\n')) {
 783         HANGING_OUTPUT=1;
 784     } else {
 785         HANGING_OUTPUT=0;
 786     }
 787 }
 788
 789 void T_CTEST_EXPORT2
 790 log_err(const char* pattern, ...)
 791 {
 792     va_list ap;
 793     first_line_err();
 794     if(strchr(pattern, '\n') != NULL) {
 795         /*
 796          * Count errors only if there is a line feed in the pattern
 797          * so that we do not exaggerate our error count.
 798          */
 799         ++ERROR_COUNT;
 800     } else {
 801         /* Count at least one error. */
 802         ONE_ERROR=1;
 803     }
 804     va_start(ap, pattern);
 805     vlog_err(NULL, pattern, ap);
 806 }
 807
 808 UBool T_CTEST_EXPORT2
 809 log_knownIssue(const char *ticket, const char *pattern, ...) {
 810   va_list ap;
 811   va_start(ap, pattern);
 812   return vlog_knownIssue(ticket, pattern, ap);
 813 }
 814
 815 void T_CTEST_EXPORT2
 816 log_err_status(UErrorCode status, const char* pattern, ...)
 817 {
 818     va_list ap;
 819     va_start(ap, pattern);
 820
 821     if ((status == U_FILE_ACCESS_ERROR || status == U_MISSING_RESOURCE_ERROR)) {
 822         ++DATA_ERROR_COUNT; /* for informational message at the end */
 823
 824         if (WARN_ON_MISSING_DATA == 0) {
 825             first_line_err();
 826             /* Fatal error. */
 827             if (strchr(pattern, '\n') != NULL) {
 828                 ++ERROR_COUNT;
 829             } else {
 830                 ++ONE_ERROR;
 831             }
 832             vlog_err(NULL, pattern, ap); /* no need for prefix in default case */
 833         } else {
 834             vlog_info("[DATA] ", pattern, ap);
 835         }
 836     } else {
 837         first_line_err();
 838         /* Fatal error. */
 839         if(strchr(pattern, '\n') != NULL) {
 840             ++ERROR_COUNT;
 841         } else {
 842             ++ONE_ERROR;
 843         }
 844         vlog_err(NULL, pattern, ap); /* no need for prefix in default case */
 845     }
 846 }
 847
 848 void T_CTEST_EXPORT2
 849 log_info(const char* pattern, ...)
 850 {
 851     va_list ap;
 852
 853     va_start(ap, pattern);
 854     vlog_info(NULL, pattern, ap);
 855 }
 856
 857 void T_CTEST_EXPORT2
 858 log_verbose(const char* pattern, ...)
 859 {
 860     va_list ap;
 861
 862     va_start(ap, pattern);
 863     vlog_verbose(NULL, pattern, ap);
 864 }
 865
 866
 867 void T_CTEST_EXPORT2
 868 log_data_err(const char* pattern, ...)
 869 {
 870     va_list ap;
 871     va_start(ap, pattern);
 872
 873     go_offline_err();
 874     ++DATA_ERROR_COUNT; /* for informational message at the end */
 875
 876     if(WARN_ON_MISSING_DATA == 0) {
 877         /* Fatal error. */
 878         if(strchr(pattern, '\n') != NULL) {
 879             ++ERROR_COUNT;
 880         }
 881         vlog_err(NULL, pattern, ap); /* no need for prefix in default case */
 882     } else {
 883         vlog_info("[DATA] ", pattern, ap);
 884     }
 885 }
 886
 887
 888 /*
 889  * Tracing functions.
 890  */
 891 static int traceFnNestingDepth = 0;
 892 U_CDECL_BEGIN
 893 static void U_CALLCONV TraceEntry(const void *context, int32_t fnNumber) {
 894     char buf[500];
 895     utrace_format(buf, sizeof(buf), traceFnNestingDepth*3, "%s() enter.\n", utrace_functionName(fnNumber));    buf[sizeof(buf)-1]=0;
 896     fputs(buf, stdout);
 897     traceFnNestingDepth++;
 898 }
 899
 900 static void U_CALLCONV TraceExit(const void *context, int32_t fnNumber, const char *fmt, va_list args) {    char buf[500];
 901
 902     if (traceFnNestingDepth>0) {
 903         traceFnNestingDepth--;
 904     }
 905     utrace_format(buf, sizeof(buf), traceFnNestingDepth*3, "%s() ", utrace_functionName(fnNumber));    buf[sizeof(buf)-1]=0;
 906     fputs(buf, stdout);
 907     utrace_vformat(buf, sizeof(buf), traceFnNestingDepth*3, fmt, args);
 908     buf[sizeof(buf)-1]=0;
 909     fputs(buf, stdout);
 910     putc('\n', stdout);
 911 }
 912
 913 static void U_CALLCONV TraceData(const void *context, int32_t fnNumber,
 914                           int32_t level, const char *fmt, va_list args) {
 915     char buf[500];
 916     utrace_vformat(buf, sizeof(buf), traceFnNestingDepth*3, fmt, args);
 917     buf[sizeof(buf)-1]=0;
 918     fputs(buf, stdout);
 919     putc('\n', stdout);
 920 }
 921
 922 static void *U_CALLCONV ctest_libMalloc(const void *context, size_t size) {
 923     /*if (VERBOSITY) {
 924         printf("Allocated %ld\n", (long)size);
 925     }*/
 926     if (MINIMUM_MEMORY_SIZE_FAILURE <= size && size <= MAXIMUM_MEMORY_SIZE_FAILURE) {
 927         return NULL;
 928     }
 929     return malloc(size);
 930 }
 931 static void *U_CALLCONV ctest_libRealloc(const void *context, void *mem, size_t size) {
 932     /*if (VERBOSITY) {
 933         printf("Reallocated %ld\n", (long)size);
 934     }*/
 935     if (MINIMUM_MEMORY_SIZE_FAILURE <= size && size <= MAXIMUM_MEMORY_SIZE_FAILURE) {
 936         /*free(mem);*/ /* Realloc doesn't free on failure. */
 937         return NULL;
 938     }
 939     return realloc(mem, size);
 940 }
 941 static void U_CALLCONV ctest_libFree(const void *context, void *mem) {
 942     free(mem);
 943 }
 944
 945 int T_CTEST_EXPORT2
 946 initArgs( int argc, const char* const argv[], ArgHandlerPtr argHandler, void *context)
 947 {
 948     int                i;
 949     int                argSkip = 0;
 950
 951     VERBOSITY = FALSE;
 952     ERR_MSG = TRUE;
 953
 954     ARGV_0=argv[0];
 955
 956     for( i=1; i<argc; i++)
 957     {
 958         if ( argv[i][0] == '/' )
 959         {
 960             /* We don't run the tests here. */
 961             continue;
 962         }
 963         else if ((strcmp( argv[i], "-a") == 0) || (strcmp(argv[i],"-all") == 0))
 964         {
 965             /* We don't run the tests here. */
 966             continue;
 967         }
 968         else if (strcmp( argv[i], "-v" )==0 || strcmp( argv[i], "-verbose")==0)
 969         {
 970             VERBOSITY = TRUE;
 971         }
 972         else if (strcmp( argv[i], "-l" )==0 )
 973         {
 974             /* doList = TRUE; */
 975         }
 976         else if (strcmp( argv[i], "-e1") == 0)
 977         {
 978             QUICK = -1;
 979         }
 980         else if (strcmp( argv[i], "-e") ==0)
 981         {
 982             QUICK = 0;
 983         }
 984         else if (strcmp( argv[i], "-K") ==0)
 985         {
 986             NO_KNOWN = 1;
 987         }
 988         else if (strncmp( argv[i], "-E",2) ==0)
 989         {
 990             SUMMARY_FILE=argv[i]+2;
 991         }
 992         else if (strcmp( argv[i], "-w") ==0)
 993         {
 994             WARN_ON_MISSING_DATA = TRUE;
 995         }
 996         else if (strcmp( argv[i], "-m") ==0)
 997         {
 998             UErrorCode errorCode = U_ZERO_ERROR;
 999             if (i+1 < argc) {
1000                 char *endPtr = NULL;
1001                 i++;
1002                 MINIMUM_MEMORY_SIZE_FAILURE = (size_t)strtol(argv[i], &endPtr, 10);
1003                 if (endPtr == argv[i]) {
1004                     printf("Can't parse %s\n", argv[i]);
1005                     help(argv[0]);
1006                     return 0;
1007                 }
1008                 if (*endPtr == '-') {
1009                     char *maxPtr = endPtr+1;
1010                     endPtr = NULL;
1011                     MAXIMUM_MEMORY_SIZE_FAILURE = (size_t)strtol(maxPtr, &endPtr, 10);
1012                     if (endPtr == argv[i]) {
1013                         printf("Can't parse %s\n", argv[i]);
1014                         help(argv[0]);
1015                         return 0;
1016                     }
1017                 }
1018             }
1019             /* Use the default value */
1020             u_setMemoryFunctions(NULL, ctest_libMalloc, ctest_libRealloc, ctest_libFree, &errorCode);
1021             if (U_FAILURE(errorCode)) {
1022                 printf("u_setMemoryFunctions returned %s\n", u_errorName(errorCode));
1023                 return 0;
1024             }
1025         }
1026         else if(strcmp( argv[i], "-n") == 0 || strcmp( argv[i], "-no_err_msg") == 0)
1027         {
1028             ERR_MSG = FALSE;
1029         }
1030         else if (strcmp( argv[i], "-r") == 0)
1031         {
1032             if (!REPEAT_TESTS_INIT) {
1033                 REPEAT_TESTS++;
1034             }
1035         }
1036         else if (strcmp( argv[i], "-x") == 0)
1037         {
1038           if(++i>=argc) {
1039             printf("* Error: '-x' option requires an argument. usage: '-x outfile.xml'.\n");
1040             return 0;
1041           }
1042           if(ctest_xml_setFileName(argv[i])) { /* set the name */
1043             return 0;
1044           }
1045         }
1046         else if (strcmp( argv[i], "-t_info") == 0) {
1047             ICU_TRACE = UTRACE_INFO;
1048         }
1049         else if (strcmp( argv[i], "-t_error") == 0) {
1050             ICU_TRACE = UTRACE_ERROR;
1051         }
1052         else if (strcmp( argv[i], "-t_warn") == 0) {
1053             ICU_TRACE = UTRACE_WARNING;
1054         }
1055         else if (strcmp( argv[i], "-t_verbose") == 0) {
1056             ICU_TRACE = UTRACE_VERBOSE;
1057         }
1058         else if (strcmp( argv[i], "-t_oc") == 0) {
1059             ICU_TRACE = UTRACE_OPEN_CLOSE;
1060         }
1061         else if (strcmp( argv[i], "-h" )==0 || strcmp( argv[i], "--help" )==0)
1062         {
1063             help( argv[0] );
1064             return 0;
1065         }
1066         else if (argHandler != NULL && (argSkip = argHandler(i, argc, argv, context)) > 0)
1067         {
1068             i += argSkip - 1;
1069         }
1070         else
1071         {
1072             printf("* unknown option: %s\n", argv[i]);
1073             help( argv[0] );
1074             return 0;
1075         }
1076     }
1077     if (ICU_TRACE != UTRACE_OFF) {
1078         utrace_setFunctions(NULL, TraceEntry, TraceExit, TraceData);
1079         utrace_setLevel(ICU_TRACE);
1080     }
1081
1082     return 1; /* total error count */
1083 }
1084
1085 int T_CTEST_EXPORT2
1086 runTestRequest(const TestNode* root,
1087              int argc,
1088              const char* const argv[])
1089 {
1090     /**
1091      * This main will parse the l, v, h, n, and path arguments
1092      */
1093     const TestNode*    toRun;
1094     int                i;
1095     int                doList = FALSE;
1096     int                subtreeOptionSeen = FALSE;
1097
1098     int                errorCount = 0;
1099
1100     toRun = root;
1101
1102     if(ctest_xml_init(ARGV_0)) {
1103       return 1; /* couldn't fire up XML thing */
1104     }
1105
1106     for( i=1; i<argc; i++)
1107     {
1108         if ( argv[i][0] == '/' )
1109         {
1110             printf("Selecting subtree '%s'\n", argv[i]);
1111
1112             if ( argv[i][1] == 0 )
1113                 toRun = root;
1114             else
1115                 toRun = getTest(root, argv[i]);
1116
1117             if ( toRun == NULL )
1118             {
1119                 printf("* Could not find any matching subtree\n");
1120                 return -1;
1121             }
1122
1123             ON_LINE=FALSE; /* just in case */
1124
1125             if( doList == TRUE)
1126                 showTests(toRun);
1127             else
1128                 runTests(toRun);
1129
1130             ON_LINE=FALSE; /* just in case */
1131
1132             errorCount += ERROR_COUNT;
1133
1134             subtreeOptionSeen = TRUE;
1135         } else if ((strcmp( argv[i], "-a") == 0) || (strcmp(argv[i],"-all") == 0)) {
1136             subtreeOptionSeen=FALSE;
1137         } else if (strcmp( argv[i], "-l") == 0) {
1138             doList = TRUE;
1139         }
1140         /* else option already handled by initArgs */
1141     }
1142
1143     if( subtreeOptionSeen == FALSE) /* no other subtree given, run the default */
1144     {
1145         ON_LINE=FALSE; /* just in case */
1146         if( doList == TRUE)
1147             showTests(toRun);
1148         else
1149             runTests(toRun);
1150         ON_LINE=FALSE; /* just in case */
1151
1152         errorCount += ERROR_COUNT;
1153     }
1154     else
1155     {
1156         if( ( doList == FALSE ) && ( errorCount > 0 ) )
1157             printf(" Total errors: %d\n", errorCount );
1158     }
1159
1160     REPEAT_TESTS_INIT = 1;
1161
1162     if(ctest_xml_fini()) {
1163       errorCount++;
1164     }
1165
1166     return errorCount; /* total error count */
1167 }
1168
1169 /**
1170  * Display program invocation arguments
1171  */
1172
1173 static void help ( const char *argv0 )
1174 {
1175     printf("Usage: %s [ -l ] [ -v ] [ -verbose] [-a] [ -all] [-n] [ -no_err_msg]\n"
1176            "    [ -h ] [-t_info | -t_error | -t_warn | -t_oc | -t_verbose] [-m n[-q] ]\n"
1177            "    [ /path/to/test ]\n",
1178             argv0);
1179     printf("    -l  To get a list of test names\n");
1180     printf("    -e  to do exhaustive testing\n");
1181     printf("    -verbose To turn ON verbosity\n");
1182     printf("    -v  To turn ON verbosity(same as -verbose)\n");
1183     printf("    -x file.xml   Write junit format output to file.xml\n");
1184     printf("    -h  To print this message\n");
1185     printf("    -K  to turn OFF suppressing known issues\n");
1186     printf("    -n  To turn OFF printing error messages\n");
1187     printf("    -w  Don't fail on data-loading errs, just warn. Useful if\n"
1188            "        user has reduced/changed the common set of ICU data \n");
1189     printf("    -t_info | -t_error | -t_warn | -t_oc | -t_verbose  Enable ICU tracing\n");
1190     printf("    -no_err_msg (same as -n) \n");
1191     printf("    -m n[-q] Min-Max memory size that will cause an allocation failure.\n");
1192     printf("        The default is the maximum value of size_t. Max is optional.\n");
1193     printf("    -r  Repeat tests after calling u_cleanup \n");
1194     printf("    [/subtest]  To run a subtest \n");
1195     printf("    eg: to run just the utility tests type: cintltest /tsutil) \n");
1196 }
1197
1198 int32_t T_CTEST_EXPORT2
1199 getTestOption ( int32_t testOption ) {
1200     switch (testOption) {
1201         case VERBOSITY_OPTION:
1202             return VERBOSITY;
1203         case WARN_ON_MISSING_DATA_OPTION:
1204             return WARN_ON_MISSING_DATA;
1205         case QUICK_OPTION:
1206             return QUICK;
1207         case REPEAT_TESTS_OPTION:
1208             return REPEAT_TESTS;
1209         case ERR_MSG_OPTION:
1210             return ERR_MSG;
1211         case ICU_TRACE_OPTION:
1212             return ICU_TRACE;
1213         default :
1214             return 0;
1215     }
1216 }
1217
1218 void T_CTEST_EXPORT2
1219 setTestOption ( int32_t testOption, int32_t value) {
1220     if (value == DECREMENT_OPTION_VALUE) {
1221         value = getTestOption(testOption);
1222         --value;
1223     }
1224     switch (testOption) {
1225         case VERBOSITY_OPTION:
1226             VERBOSITY = value;
1227             break;
1228         case WARN_ON_MISSING_DATA_OPTION:
1229             WARN_ON_MISSING_DATA = value;
1230             break;
1231         case QUICK_OPTION:
1232             QUICK = value;
1233             break;
1234         case REPEAT_TESTS_OPTION:
1235             REPEAT_TESTS = value;
1236             break;
1237         case ICU_TRACE_OPTION:
1238             ICU_TRACE = (UTraceLevel)value;
1239             break;
1240         default :
1241             break;
1242     }
1243 }
1244
1245
1246 /*
1247  * ================== JUnit support ================================
1248  */
1249
1250 int32_t
1251 T_CTEST_EXPORT2
1252 ctest_xml_setFileName(const char *name) {
1253   XML_FILE_NAME=name;
1254   return 0;
1255 }
1256
1257
1258 int32_t
1259 T_CTEST_EXPORT2
1260 ctest_xml_init(const char *rootName) {
1261   if(!XML_FILE_NAME) return 0;
1262   XML_FILE = fopen(XML_FILE_NAME,"w");
1263   if(!XML_FILE) {
1264     perror("fopen");
1265     fprintf(stderr," Error: couldn't open XML output file %s\n", XML_FILE_NAME);
1266     return 1;
1267   }
1268   while(*rootName&&!isalnum((int)*rootName)) {
1269     rootName++;
1270   }
1271   strcpy(XML_PREFIX,rootName);
1272   {
1273     char *p = XML_PREFIX+strlen(XML_PREFIX);
1274     for(p--;*p&&p>XML_PREFIX&&!isalnum((int)*p);p--) {
1275       *p=0;
1276     }
1277   }
1278   /* write prefix */
1279   fprintf(XML_FILE, "<testsuite name=\"%s\">\n", XML_PREFIX);
1280
1281   return 0;
1282 }
1283
1284 int32_t
1285 T_CTEST_EXPORT2
1286 ctest_xml_fini(void) {
1287   if(!XML_FILE) return 0;
1288
1289   fprintf(XML_FILE, "</testsuite>\n");
1290   fclose(XML_FILE);
1291   printf(" ( test results written to %s )\n", XML_FILE_NAME);
1292   XML_FILE=0;
1293   return 0;
1294 }
1295
1296
1297 int32_t
1298 T_CTEST_EXPORT2
1299 ctest_xml_testcase(const char *classname, const char *name, const char *timeSeconds, const char *failMsg) {
1300   if(!XML_FILE) return 0;
1301
1302   fprintf(XML_FILE, "\t<testcase classname=\"%s:%s\" name=\"%s:%s\" time=\"%s\"", XML_PREFIX, classname, XML_PREFIX, name, timeSeconds);
1303   if(failMsg) {
1304     fprintf(XML_FILE, ">\n\t\t<failure type=\"err\" message=\"%s\"/>\n\t</testcase>\n", failMsg);
1305   } else {
1306     fprintf(XML_FILE, "/>\n");
1307   }
1308
1309   return 0;
1310 }
1311
1312