Home | History | Annotate | Download | only in ctestfw
      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 
   1313