// © 2016 and later: Unicode, Inc. and others. // License & terms of use: http://www.unicode.org/copyright.html /* ******************************************************************************** * * Copyright (C) 1996-2014, International Business Machines * Corporation and others. All Rights Reserved. * ******************************************************************************** */ #include "unicode/ctest.h" #include #include #include #include #include #include #include #if defined(__ANDROID__) #include #include #include #endif #if defined(__linux__) #include #endif #if defined(__GLIBC__) // Glibc's PATH_MAX is not in limits.h. #include #endif #include "unicode/utrace.h" #include "unicode/uclean.h" #include "unicode/ures.h" #include "putilimp.h" #include "udbgutil.h" /* NOTES: 3/20/1999 srl - strncpy called w/o setting nulls at the end */ #define MAXTESTNAME 128 #define MAXTESTS 512 #define MAX_TEST_LOG 4096 /** * How may columns to indent the 'OK' markers. */ #define FLAG_INDENT 45 /** * How many lines of scrollage can go by before we need to remind the user what the test is. */ #define PAGE_SIZE_LIMIT 25 #ifndef SHOW_TIMES #define SHOW_TIMES 1 #endif #if defined(_WIN32) #define PATH_MAX MAX_PATH #elif !defined(PATH_MAX) #define PATH_MAX 256 // The minimum value allowed by POSIX. #endif struct TestNode { void (*test)(void); struct TestNode* sibling; struct TestNode* child; char name[1]; /* This is dynamically allocated off the end with malloc. */ }; static const struct TestNode* currentTest; typedef enum { RUNTESTS, SHOWTESTS } TestMode; #define TEST_SEPARATOR '/' #ifndef C_TEST_IMPL #define C_TEST_IMPL #endif #include "unicode/ctest.h" static char ERROR_LOG[MAX_TEST_LOG][MAXTESTNAME]; /* Local prototypes */ static TestNode* addTestNode( TestNode *root, const char *name ); static TestNode *createTestNode(const char* name, int32_t nameLen); static int strncmp_nullcheck( const char* s1, const char* s2, int n ); static void getNextLevel( const char* name, int* nameLen, const char** nextName ); static void iterateTestsWithLevel( const TestNode *root, int depth, const TestNode** nodeList, TestMode mode); static void help ( const char *argv0 ); /** * Do the work of logging an error. Doesn't increase the error count. * * @prefix optional prefix prepended to message, or NULL. * @param pattern printf style pattern * @param ap vprintf style arg list */ static void vlog_err(const char *prefix, const char *pattern, va_list ap); static void vlog_verbose(const char *prefix, const char *pattern, va_list ap); static UBool vlog_knownIssue(const char *ticket, const char *pattern, va_list ap); /** * Log test structure, with indent * @param pattern printf pattern */ static void log_testinfo_i(const char *pattern, ...); /** * Log test structure, NO indent * @param pattern printf pattern */ static void log_testinfo(const char *pattern, ...); /* If we need to make the framework multi-thread safe we need to pass around the following vars */ static int ERRONEOUS_FUNCTION_COUNT = 0; static int ERROR_COUNT = 0; /* Count of errors from all tests. */ static int ONE_ERROR = 0; /* were there any other errors? */ static int DATA_ERROR_COUNT = 0; /* count of data related errors or warnings */ static int INDENT_LEVEL = 0; static UBool NO_KNOWN = FALSE; static void *knownList = NULL; static char gTestName[1024] = ""; static UBool ON_LINE = FALSE; /* are we on the top line with our test name? */ static UBool HANGING_OUTPUT = FALSE; /* did the user leave us without a trailing \n ? */ static int GLOBAL_PRINT_COUNT = 0; /* global count of printouts */ int REPEAT_TESTS_INIT = 0; /* Was REPEAT_TESTS initialized? */ int REPEAT_TESTS = 1; /* Number of times to run the test */ int VERBOSITY = 0; /* be No-verbose by default */ int ERR_MSG =1; /* error messages will be displayed by default*/ int QUICK = 1; /* Skip some of the slower tests? */ int WARN_ON_MISSING_DATA = 0; /* Reduce data errs to warnings? */ UTraceLevel ICU_TRACE = UTRACE_OFF; /* ICU tracing level */ size_t MINIMUM_MEMORY_SIZE_FAILURE = (size_t)-1; /* Minimum library memory allocation window that will fail. */ size_t MAXIMUM_MEMORY_SIZE_FAILURE = (size_t)-1; /* Maximum library memory allocation window that will fail. */ static const char *ARGV_0 = "[ALL]"; static const char *XML_FILE_NAME=NULL; static char XML_PREFIX[256]; static const char *SUMMARY_FILE = NULL; FILE *XML_FILE = NULL; /*-------------------------------------------*/ /* strncmp that also makes sure there's a \0 at s2[0] */ static int strncmp_nullcheck( const char* s1, const char* s2, int n ) { if (((int)strlen(s2) >= n) && s2[n] != 0) { return 3; /* null check fails */ } else { return strncmp ( s1, s2, n ); } } static void getNextLevel( const char* name, int* nameLen, const char** nextName ) { /* Get the next component of the name */ *nextName = strchr(name, TEST_SEPARATOR); if( *nextName != 0 ) { char n[255]; *nameLen = (int)((*nextName) - name); (*nextName)++; /* skip '/' */ strncpy(n, name, *nameLen); n[*nameLen] = 0; /*printf("->%s-< [%d] -> [%s]\n", name, *nameLen, *nextName);*/ } else { *nameLen = (int)strlen(name); } } static TestNode *createTestNode(const char* name, int32_t nameLen) { TestNode *newNode; newNode = (TestNode*)malloc(sizeof(TestNode) + (nameLen + 1)); newNode->test = NULL; newNode->sibling = NULL; newNode->child = NULL; strncpy( newNode->name, name, nameLen ); newNode->name[nameLen] = 0; return newNode; } void T_CTEST_EXPORT2 cleanUpTestTree(TestNode *tn) { if(tn->child != NULL) { cleanUpTestTree(tn->child); } if(tn->sibling != NULL) { cleanUpTestTree(tn->sibling); } free(tn); } void T_CTEST_EXPORT2 addTest(TestNode** root, TestFunctionPtr test, const char* name ) { TestNode *newNode; /*if this is the first Test created*/ if (*root == NULL) *root = createTestNode("", 0); newNode = addTestNode( *root, name ); assert(newNode != 0 ); /* printf("addTest: nreName = %s\n", newNode->name );*/ newNode->test = test; } /* non recursive insert function */ static TestNode *addTestNode ( TestNode *root, const char *name ) { const char* nextName; TestNode *nextNode, *curNode; int nameLen; /* length of current 'name' */ /* remove leading slash */ if ( *name == TEST_SEPARATOR ) name++; curNode = root; for(;;) { /* Start with the next child */ nextNode = curNode->child; getNextLevel ( name, &nameLen, &nextName ); /* printf("* %s\n", name );*/ /* if nextNode is already null, then curNode has no children -- add them */ if( nextNode == NULL ) { /* Add all children of the node */ do { /* Get the next component of the name */ getNextLevel(name, &nameLen, &nextName); /* update curName to have the next name segment */ curNode->child = createTestNode(name, nameLen); /* printf("*** added %s\n", curNode->child->name );*/ curNode = curNode->child; name = nextName; } while( name != NULL ); return curNode; } /* Search across for the name */ while (strncmp_nullcheck ( name, nextNode->name, nameLen) != 0 ) { curNode = nextNode; nextNode = nextNode -> sibling; if ( nextNode == NULL ) { /* Did not find 'name' on this level. */ nextNode = createTestNode(name, nameLen); curNode->sibling = nextNode; break; } } /* nextNode matches 'name' */ if (nextName == NULL) /* end of the line */ { return nextNode; } /* Loop again with the next item */ name = nextName; curNode = nextNode; } } /** * Log the time taken. May not output anything. * @param deltaTime change in time */ void T_CTEST_EXPORT2 str_timeDelta(char *str, UDate deltaTime) { if (deltaTime > 110000.0 ) { double mins = uprv_floor(deltaTime/60000.0); sprintf(str, "[(%.0fm %.1fs)]", mins, (deltaTime-(mins*60000.0))/1000.0); } else if (deltaTime > 1500.0) { sprintf(str, "((%.1fs))", deltaTime/1000.0); } else if(deltaTime>900.0) { sprintf(str, "( %.2fs )", deltaTime/1000.0); } else if(deltaTime > 5.0) { sprintf(str, " (%.0fms) ", deltaTime); } else { str[0]=0; /* at least terminate it. */ } } static void print_timeDelta(UDate deltaTime) { char str[256]; str_timeDelta(str, deltaTime); if(str[0]) { printf("%s", str); } } /** * Run or list tests (according to mode) in a subtree. * * @param root root of the subtree to operate on * @param depth The depth of this tree (0=root) * @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. * @param mode what mode we are operating in. */ static void iterateTestsWithLevel ( const TestNode* root, int depth, const TestNode** nodeList, TestMode mode) { int i; char pathToFunction[MAXTESTNAME] = ""; char separatorString[2] = { TEST_SEPARATOR, '\0'}; #if SHOW_TIMES UDate allStartTime = -1, allStopTime = -1; #endif if(depth<2) { allStartTime = uprv_getRawUTCtime(); } if ( root == NULL ) return; /* record the current root node, and increment depth. */ nodeList[depth++] = root; /* depth is now the depth of root's children. */ /* Collect the 'path' to the current subtree. */ for ( i=0;i<(depth-1);i++ ) { strcat(pathToFunction, nodeList[i]->name); strcat(pathToFunction, separatorString); } strcat(pathToFunction, nodeList[i]->name); /* including 'root' */ /* print test name and space. */ INDENT_LEVEL = depth-1; if(root->name[0]) { log_testinfo_i("%s ", root->name); } else { log_testinfo_i("(%s) ", ARGV_0); } ON_LINE = TRUE; /* we are still on the line with the test name */ if ( (mode == RUNTESTS) && (root->test != NULL)) /* if root is a leaf node, run it */ { int myERROR_COUNT = ERROR_COUNT; int myGLOBAL_PRINT_COUNT = GLOBAL_PRINT_COUNT; #if SHOW_TIMES UDate startTime, stopTime; char timeDelta[256]; char timeSeconds[256]; #else const char timeDelta[] = "(unknown)"; const char timeSeconds[] = "0.000"; #endif currentTest = root; INDENT_LEVEL = depth; /* depth of subitems */ ONE_ERROR=0; HANGING_OUTPUT=FALSE; #if SHOW_TIMES startTime = uprv_getRawUTCtime(); #endif strcpy(gTestName, pathToFunction); root->test(); /* PERFORM THE TEST ************************/ #if SHOW_TIMES stopTime = uprv_getRawUTCtime(); #endif if(HANGING_OUTPUT) { log_testinfo("\n"); HANGING_OUTPUT=FALSE; } INDENT_LEVEL = depth-1; /* depth of root */ currentTest = NULL; if((ONE_ERROR>0)&&(ERROR_COUNT==0)) { ERROR_COUNT++; /* There was an error without a newline */ } ONE_ERROR=0; #if SHOW_TIMES str_timeDelta(timeDelta, stopTime-startTime); sprintf(timeSeconds, "%f", (stopTime-startTime)/1000.0); #endif ctest_xml_testcase(pathToFunction, pathToFunction, timeSeconds, (myERROR_COUNT!=ERROR_COUNT)?"error":NULL); if (myERROR_COUNT != ERROR_COUNT) { log_testinfo_i("} ---[%d ERRORS in %s] ", ERROR_COUNT - myERROR_COUNT, pathToFunction); strcpy(ERROR_LOG[ERRONEOUS_FUNCTION_COUNT++], pathToFunction); } else { if(!ON_LINE) { /* had some output */ int spaces = FLAG_INDENT-(depth-1); log_testinfo_i("} %*s[OK] ", spaces, "---"); if((GLOBAL_PRINT_COUNT-myGLOBAL_PRINT_COUNT)>PAGE_SIZE_LIMIT) { log_testinfo(" %s ", pathToFunction); /* in case they forgot. */ } } else { /* put -- out at 30 sp. */ int spaces = FLAG_INDENT - ((int)strlen(root->name) + depth); if(spaces<0) spaces=0; log_testinfo(" %*s[OK] ", spaces,"---"); } } #if SHOW_TIMES if(timeDelta[0]) printf("%s", timeDelta); #endif ON_LINE = TRUE; /* we are back on-line */ } INDENT_LEVEL = depth-1; /* root */ /* we want these messages to be at 0 indent. so just push the indent level breifly. */ if(mode==SHOWTESTS) { log_testinfo("---%s%c\n",pathToFunction, nodeList[i]->test?' ':TEST_SEPARATOR ); } INDENT_LEVEL = depth; if(root->child) { int myERROR_COUNT = ERROR_COUNT; int myGLOBAL_PRINT_COUNT = GLOBAL_PRINT_COUNT; if(mode!=SHOWTESTS) { INDENT_LEVEL=depth-1; log_testinfo("{\n"); INDENT_LEVEL=depth; } iterateTestsWithLevel ( root->child, depth, nodeList, mode ); if(mode!=SHOWTESTS) { INDENT_LEVEL=depth-1; log_testinfo_i("} "); /* TODO: summarize subtests */ if((depth>1) && (ERROR_COUNT > myERROR_COUNT)) { log_testinfo("[%d %s in %s] ", ERROR_COUNT-myERROR_COUNT, (ERROR_COUNT-myERROR_COUNT)==1?"error":"errors", pathToFunction); } else if((GLOBAL_PRINT_COUNT-myGLOBAL_PRINT_COUNT)>PAGE_SIZE_LIMIT || (depth<1)) { if(pathToFunction[0]) { log_testinfo(" %s ", pathToFunction); /* in case they forgot. */ } else { log_testinfo(" / (%s) ", ARGV_0); } } ON_LINE=TRUE; } } depth--; #if SHOW_TIMES if(depth<2) { allStopTime = uprv_getRawUTCtime(); print_timeDelta(allStopTime-allStartTime); } #endif if(mode!=SHOWTESTS && ON_LINE) { log_testinfo("\n"); } if ( depth != 0 ) { /* DO NOT iterate over siblings of the root. TODO: why not? */ iterateTestsWithLevel ( root->sibling, depth, nodeList, mode ); } } void T_CTEST_EXPORT2 showTests ( const TestNode *root ) { /* make up one for them */ const TestNode *nodeList[MAXTESTS]; if (root == NULL) log_err("TEST CAN'T BE FOUND!"); iterateTestsWithLevel ( root, 0, nodeList, SHOWTESTS ); } void T_CTEST_EXPORT2 runTests ( const TestNode *root ) { int i; const TestNode *nodeList[MAXTESTS]; /* make up one for them */ if (root == NULL) log_err("TEST CAN'T BE FOUND!\n"); ERRONEOUS_FUNCTION_COUNT = ERROR_COUNT = 0; iterateTestsWithLevel ( root, 0, nodeList, RUNTESTS ); /*print out result summary*/ ON_LINE=FALSE; /* just in case */ if(knownList != NULL) { if( udbg_knownIssue_print(knownList) ) { fprintf(stdout, "(To run suppressed tests, use the -K option.) \n\n"); } udbg_knownIssue_close(knownList); knownList = NULL; } if (ERROR_COUNT) { fprintf(stdout,"\nSUMMARY:\n"); fflush(stdout); fprintf(stdout,"******* [Total error count:\t%d]\n", ERROR_COUNT); fflush(stdout); fprintf(stdout, " Errors in\n"); for (i=0;i < ERRONEOUS_FUNCTION_COUNT; i++) fprintf(stdout, "[%s]\n",ERROR_LOG[i]); if(SUMMARY_FILE != NULL) { FILE *summf = fopen(SUMMARY_FILE, "w"); if(summf!=NULL) { for (i=0;i < ERRONEOUS_FUNCTION_COUNT; i++) fprintf(summf, "%s\n",ERROR_LOG[i]); fclose(summf); } } } else { log_testinfo("\n[All tests passed successfully...]\n"); } if(DATA_ERROR_COUNT) { if(WARN_ON_MISSING_DATA==0) { log_testinfo("\t*Note* some errors are data-loading related. If the data used is not the \n" "\tstock ICU data (i.e some have been added or removed), consider using\n" "\tthe '-w' option to turn these errors into warnings.\n"); } else { log_testinfo("\t*WARNING* some data-loading errors were ignored by the -w option.\n"); } } } const char* T_CTEST_EXPORT2 getTestName(void) { if(currentTest != NULL) { return currentTest->name; } else { return NULL; } } const TestNode* T_CTEST_EXPORT2 getTest(const TestNode* root, const char* name) { const char* nextName; TestNode *nextNode; const TestNode* curNode; int nameLen; /* length of current 'name' */ if (root == NULL) { log_err("TEST CAN'T BE FOUND!\n"); return NULL; } /* remove leading slash */ if ( *name == TEST_SEPARATOR ) name++; curNode = root; for(;;) { /* Start with the next child */ nextNode = curNode->child; getNextLevel ( name, &nameLen, &nextName ); /* printf("* %s\n", name );*/ /* if nextNode is already null, then curNode has no children -- add them */ if( nextNode == NULL ) { return NULL; } /* Search across for the name */ while (strncmp_nullcheck ( name, nextNode->name, nameLen) != 0 ) { curNode = nextNode; nextNode = nextNode -> sibling; if ( nextNode == NULL ) { /* Did not find 'name' on this level. */ return NULL; } } /* nextNode matches 'name' */ if (nextName == NULL) /* end of the line */ { return nextNode; } /* Loop again with the next item */ name = nextName; curNode = nextNode; } } /* =========== io functions ======== */ static void go_offline_with_marker(const char *mrk) { UBool wasON_LINE = ON_LINE; if(ON_LINE) { log_testinfo(" {\n"); ON_LINE=FALSE; } if(!HANGING_OUTPUT || wasON_LINE) { if(mrk != NULL) { fputs(mrk, stdout); } } } static void go_offline() { go_offline_with_marker(NULL); } static void go_offline_err() { go_offline(); } static void first_line_verbose() { go_offline_with_marker("v"); } static void first_line_err() { go_offline_with_marker("!"); } static void first_line_info() { go_offline_with_marker("\""); } static void first_line_test() { fputs(" ", stdout); } static void vlog_err(const char *prefix, const char *pattern, va_list ap) { if( ERR_MSG == FALSE){ return; } fputs("!", stdout); /* col 1 - bang */ fprintf(stdout, "%-*s", INDENT_LEVEL,"" ); if(prefix) { fputs(prefix, stdout); } vfprintf(stdout, pattern, ap); fflush(stdout); va_end(ap); if((*pattern==0) || (pattern[strlen(pattern)-1]!='\n')) { HANGING_OUTPUT=1; } else { HANGING_OUTPUT=0; } GLOBAL_PRINT_COUNT++; } static UBool vlog_knownIssue(const char *ticket, const char *pattern, va_list ap) { char buf[2048]; UBool firstForTicket; UBool firstForWhere; if(NO_KNOWN) return FALSE; if(pattern==NULL) pattern=""; vsprintf(buf, pattern, ap); knownList = udbg_knownIssue_open(knownList, ticket, gTestName, buf, &firstForTicket, &firstForWhere); if(firstForTicket || firstForWhere) { log_info("(Known issue %s) %s\n", ticket, buf); } else { log_verbose("(Known issue %s) %s\n", ticket, buf); } return TRUE; } void T_CTEST_EXPORT2 vlog_info(const char *prefix, const char *pattern, va_list ap) { first_line_info(); fprintf(stdout, "%-*s", INDENT_LEVEL,"" ); if(prefix) { fputs(prefix, stdout); } vfprintf(stdout, pattern, ap); fflush(stdout); va_end(ap); if((*pattern==0) || (pattern[strlen(pattern)-1]!='\n')) { HANGING_OUTPUT=1; } else { HANGING_OUTPUT=0; } GLOBAL_PRINT_COUNT++; } /** * Log test structure, with indent */ static void log_testinfo_i(const char *pattern, ...) { va_list ap; first_line_test(); fprintf(stdout, "%-*s", INDENT_LEVEL,"" ); va_start(ap, pattern); vfprintf(stdout, pattern, ap); fflush(stdout); va_end(ap); GLOBAL_PRINT_COUNT++; } /** * Log test structure (no ident) */ static void log_testinfo(const char *pattern, ...) { va_list ap; va_start(ap, pattern); first_line_test(); vfprintf(stdout, pattern, ap); fflush(stdout); va_end(ap); GLOBAL_PRINT_COUNT++; } static void vlog_verbose(const char *prefix, const char *pattern, va_list ap) { if ( VERBOSITY == FALSE ) return; first_line_verbose(); fprintf(stdout, "%-*s", INDENT_LEVEL,"" ); if(prefix) { fputs(prefix, stdout); } vfprintf(stdout, pattern, ap); fflush(stdout); va_end(ap); GLOBAL_PRINT_COUNT++; if((*pattern==0) || (pattern[strlen(pattern)-1]!='\n')) { HANGING_OUTPUT=1; } else { HANGING_OUTPUT=0; } } void T_CTEST_EXPORT2 log_err(const char* pattern, ...) { va_list ap; first_line_err(); if(strchr(pattern, '\n') != NULL) { /* * Count errors only if there is a line feed in the pattern * so that we do not exaggerate our error count. */ ++ERROR_COUNT; } else { /* Count at least one error. */ ONE_ERROR=1; } va_start(ap, pattern); vlog_err(NULL, pattern, ap); } UBool T_CTEST_EXPORT2 log_knownIssue(const char *ticket, const char *pattern, ...) { va_list ap; va_start(ap, pattern); return vlog_knownIssue(ticket, pattern, ap); } void T_CTEST_EXPORT2 log_err_status(UErrorCode status, const char* pattern, ...) { va_list ap; va_start(ap, pattern); if ((status == U_FILE_ACCESS_ERROR || status == U_MISSING_RESOURCE_ERROR)) { ++DATA_ERROR_COUNT; /* for informational message at the end */ if (WARN_ON_MISSING_DATA == 0) { first_line_err(); /* Fatal error. */ if (strchr(pattern, '\n') != NULL) { ++ERROR_COUNT; } else { ++ONE_ERROR; } vlog_err(NULL, pattern, ap); /* no need for prefix in default case */ } else { vlog_info("[DATA] ", pattern, ap); } } else { first_line_err(); /* Fatal error. */ if(strchr(pattern, '\n') != NULL) { ++ERROR_COUNT; } else { ++ONE_ERROR; } vlog_err(NULL, pattern, ap); /* no need for prefix in default case */ } } void T_CTEST_EXPORT2 log_info(const char* pattern, ...) { va_list ap; va_start(ap, pattern); vlog_info(NULL, pattern, ap); } void T_CTEST_EXPORT2 log_verbose(const char* pattern, ...) { va_list ap; va_start(ap, pattern); vlog_verbose(NULL, pattern, ap); } void T_CTEST_EXPORT2 log_data_err(const char* pattern, ...) { va_list ap; va_start(ap, pattern); go_offline_err(); ++DATA_ERROR_COUNT; /* for informational message at the end */ if(WARN_ON_MISSING_DATA == 0) { /* Fatal error. */ if(strchr(pattern, '\n') != NULL) { ++ERROR_COUNT; } vlog_err(NULL, pattern, ap); /* no need for prefix in default case */ } else { vlog_info("[DATA] ", pattern, ap); } } /* * Tracing functions. */ static int traceFnNestingDepth = 0; U_CDECL_BEGIN static void U_CALLCONV TraceEntry(const void *context, int32_t fnNumber) { char buf[500]; utrace_format(buf, sizeof(buf), traceFnNestingDepth*3, "%s() enter.\n", utrace_functionName(fnNumber)); buf[sizeof(buf)-1]=0; fputs(buf, stdout); traceFnNestingDepth++; } static void U_CALLCONV TraceExit(const void *context, int32_t fnNumber, const char *fmt, va_list args) { char buf[500]; if (traceFnNestingDepth>0) { traceFnNestingDepth--; } utrace_format(buf, sizeof(buf), traceFnNestingDepth*3, "%s() ", utrace_functionName(fnNumber)); buf[sizeof(buf)-1]=0; fputs(buf, stdout); utrace_vformat(buf, sizeof(buf), traceFnNestingDepth*3, fmt, args); buf[sizeof(buf)-1]=0; fputs(buf, stdout); putc('\n', stdout); } static void U_CALLCONV TraceData(const void *context, int32_t fnNumber, int32_t level, const char *fmt, va_list args) { char buf[500]; utrace_vformat(buf, sizeof(buf), traceFnNestingDepth*3, fmt, args); buf[sizeof(buf)-1]=0; fputs(buf, stdout); putc('\n', stdout); } static void *U_CALLCONV ctest_libMalloc(const void *context, size_t size) { /*if (VERBOSITY) { printf("Allocated %ld\n", (long)size); }*/ if (MINIMUM_MEMORY_SIZE_FAILURE <= size && size <= MAXIMUM_MEMORY_SIZE_FAILURE) { return NULL; } return malloc(size); } static void *U_CALLCONV ctest_libRealloc(const void *context, void *mem, size_t size) { /*if (VERBOSITY) { printf("Reallocated %ld\n", (long)size); }*/ if (MINIMUM_MEMORY_SIZE_FAILURE <= size && size <= MAXIMUM_MEMORY_SIZE_FAILURE) { /*free(mem);*/ /* Realloc doesn't free on failure. */ return NULL; } return realloc(mem, size); } static void U_CALLCONV ctest_libFree(const void *context, void *mem) { free(mem); } int T_CTEST_EXPORT2 initArgs( int argc, const char* const argv[], ArgHandlerPtr argHandler, void *context) { int i; int argSkip = 0; VERBOSITY = FALSE; ERR_MSG = TRUE; ARGV_0=argv[0]; for( i=1; i=argc) { printf("* Error: '-x' option requires an argument. usage: '-x outfile.xml'.\n"); return 0; } if(ctest_xml_setFileName(argv[i])) { /* set the name */ return 0; } } else if (strcmp( argv[i], "-t_info") == 0) { ICU_TRACE = UTRACE_INFO; } else if (strcmp( argv[i], "-t_error") == 0) { ICU_TRACE = UTRACE_ERROR; } else if (strcmp( argv[i], "-t_warn") == 0) { ICU_TRACE = UTRACE_WARNING; } else if (strcmp( argv[i], "-t_verbose") == 0) { ICU_TRACE = UTRACE_VERBOSE; } else if (strcmp( argv[i], "-t_oc") == 0) { ICU_TRACE = UTRACE_OPEN_CLOSE; } else if (strcmp( argv[i], "-h" )==0 || strcmp( argv[i], "--help" )==0) { help( argv[0] ); return 0; } else if (argHandler != NULL && (argSkip = argHandler(i, argc, argv, context)) > 0) { i += argSkip - 1; } else { printf("* unknown option: %s\n", argv[i]); help( argv[0] ); return 0; } } if (ICU_TRACE != UTRACE_OFF) { utrace_setFunctions(NULL, TraceEntry, TraceExit, TraceData); utrace_setLevel(ICU_TRACE); } return 1; /* total error count */ } int T_CTEST_EXPORT2 runTestRequest(const TestNode* root, int argc, const char* const argv[]) { /** * This main will parse the l, v, h, n, and path arguments */ const TestNode* toRun; int i; int doList = FALSE; int subtreeOptionSeen = FALSE; int skipNext = FALSE; int errorCount = 0; toRun = root; if(ctest_xml_init(ARGV_0)) { return 1; /* couldn't fire up XML thing */ } for( i=1; i 0 ) ) printf(" Total errors: %d\n", errorCount ); } REPEAT_TESTS_INIT = 1; if(ctest_xml_fini()) { errorCount++; } return errorCount; /* total error count */ } /** * Display program invocation arguments */ static void help ( const char *argv0 ) { printf("Usage: %s [ -l ] [ -v ] [ -verbose] [-a] [ -all] [-n] [ -no_err_msg]\n" " [ -h ] [-t_info | -t_error | -t_warn | -t_oc | -t_verbose] [-m n[-q] ]\n" " [ /path/to/test ]\n", argv0); printf(" -l To get a list of test names\n"); printf(" -e to do exhaustive testing\n"); printf(" -verbose To turn ON verbosity\n"); printf(" -v To turn ON verbosity(same as -verbose)\n"); printf(" -x file.xml Write junit format output to file.xml\n"); printf(" -h To print this message\n"); printf(" -K to turn OFF suppressing known issues\n"); printf(" -n To turn OFF printing error messages\n"); printf(" -w Don't fail on data-loading errs, just warn. Useful if\n" " user has reduced/changed the common set of ICU data \n"); printf(" -t_info | -t_error | -t_warn | -t_oc | -t_verbose Enable ICU tracing\n"); printf(" -no_err_msg (same as -n) \n"); printf(" -m n[-q] Min-Max memory size that will cause an allocation failure.\n"); printf(" The default is the maximum value of size_t. Max is optional.\n"); printf(" -r Repeat tests after calling u_cleanup \n"); printf(" [/subtest] To run a subtest \n"); printf(" eg: to run just the utility tests type: cintltest /tsutil) \n"); } int32_t T_CTEST_EXPORT2 getTestOption ( int32_t testOption ) { switch (testOption) { case VERBOSITY_OPTION: return VERBOSITY; case WARN_ON_MISSING_DATA_OPTION: return WARN_ON_MISSING_DATA; case QUICK_OPTION: return QUICK; case REPEAT_TESTS_OPTION: return REPEAT_TESTS; case ERR_MSG_OPTION: return ERR_MSG; case ICU_TRACE_OPTION: return ICU_TRACE; default : return 0; } } void T_CTEST_EXPORT2 setTestOption ( int32_t testOption, int32_t value) { if (value == DECREMENT_OPTION_VALUE) { value = getTestOption(testOption); --value; } switch (testOption) { case VERBOSITY_OPTION: VERBOSITY = value; break; case WARN_ON_MISSING_DATA_OPTION: WARN_ON_MISSING_DATA = value; break; case QUICK_OPTION: QUICK = value; break; case REPEAT_TESTS_OPTION: REPEAT_TESTS = value; break; case ICU_TRACE_OPTION: ICU_TRACE = (UTraceLevel)value; break; default : break; } } /* * ================== JUnit support ================================ */ int32_t T_CTEST_EXPORT2 ctest_xml_setFileName(const char *name) { XML_FILE_NAME=name; return 0; } int32_t T_CTEST_EXPORT2 ctest_xml_init(const char *rootName) { if(!XML_FILE_NAME) return 0; XML_FILE = fopen(XML_FILE_NAME,"w"); if(!XML_FILE) { perror("fopen"); fprintf(stderr," Error: couldn't open XML output file %s\n", XML_FILE_NAME); return 1; } while(*rootName&&!isalnum((int)*rootName)) { rootName++; } strcpy(XML_PREFIX,rootName); { char *p = XML_PREFIX+strlen(XML_PREFIX); for(p--;*p&&p>XML_PREFIX&&!isalnum((int)*p);p--) { *p=0; } } /* write prefix */ fprintf(XML_FILE, "\n", XML_PREFIX); return 0; } int32_t T_CTEST_EXPORT2 ctest_xml_fini(void) { if(!XML_FILE) return 0; fprintf(XML_FILE, "\n"); fclose(XML_FILE); printf(" ( test results written to %s )\n", XML_FILE_NAME); XML_FILE=0; return 0; } int32_t T_CTEST_EXPORT2 ctest_xml_testcase(const char *classname, const char *name, const char *timeSeconds, const char *failMsg) { if(!XML_FILE) return 0; fprintf(XML_FILE, "\t\n\t\t\n\t\n", failMsg); } else { fprintf(XML_FILE, "/>\n"); } return 0; } static const char* ctest_icuSrcDir(void) { static const char* srcDir = NULL; if (srcDir) { return srcDir; } #if defined(__ANDROID__) /* * On Android, the source tree is not available as the tests are cross * compiled. Test data is found at paths relative to the test binary. */ char exePath[PATH_MAX]; ssize_t len = readlink("/proc/self/exe", exePath, sizeof(exePath)); if (len == -1) { fprintf(stderr, "Failed to read /proc/self/exe: %s\n", strerror(errno)); abort(); } exePath[len] = '\0'; static char path[PATH_MAX]; snprintf(path, sizeof(path), "%s/", dirname(exePath)); srcDir = path; #elif defined(U_TOPSRCDIR) /* U_TOPSRCDIR is set by the makefiles on UNIXes when building cintltst and * intltst to point to the top of the build hierarchy, which may or may not * be the same as the source directory, depending on the configure options * used. At any rate, set the data path to the built data from this * directory. The value is complete with quotes, so it can be used as-is as * a string constant. */ srcDir = U_TOPSRCDIR U_FILE_SEP_STRING; #elif defined(_WIN32) /* On Windows, the file name obtained from __FILE__ includes a full path. * This file is "wherever\icu\source\test\cintltst\cintltst.c" Change to * "wherever\icu\source\data" */ static char p[sizeof(__FILE__) + 20]; char* pBackSlash; int i; strcpy(p, __FILE__); /* We want to back over three '\' chars. */ /* Only Windows should end up here, so looking for '\' is safe. */ for (i=1; i<=3; i++) { pBackSlash = strrchr(p, U_FILE_SEP_CHAR); if (pBackSlash != NULL) { *pBackSlash = 0; /* Truncate the string at the '\' */ } } if (pBackSlash != NULL) { /* We found and truncated three names from the path. * Now append "source\data" and set the environment */ strcpy(pBackSlash, U_FILE_SEP_STRING); srcDir = p; } else { /* __FILE__ on MSVC7 does not contain the directory */ FILE* file = fopen(".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "runConfigureICU", "r"); if (file) { fclose(file); srcDir = ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING; } else { srcDir = ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING; } } #else #error ctest_icuSrcDir not implemented on this platform. #endif return srcDir; } const char* T_CTEST_EXPORT2 ctest_dataSrcDir(void) { static char path[PATH_MAX]; if (path[0]) { return path; } snprintf(path, sizeof(path), "%sdata%s", ctest_icuSrcDir(), U_FILE_SEP_STRING); return path; } const char* T_CTEST_EXPORT2 ctest_dataOutDir(void) { static char path[PATH_MAX]; if (path[0]) { return path; } // Try the ICU_DATA environment variable first. This is the default location // since the user will have explicitly requested it. const char* fromEnv = getenv("ICU_DATA"); if (fromEnv != NULL && fromEnv[0] != '\0') { snprintf(path, sizeof(path), "%s%s", fromEnv, U_FILE_SEP_STRING); return path; } #if defined(__ANDROID__) // Android has the ICU data installed to a known location on the device. Use // that if ICU_DATA is not set. snprintf(path, sizeof(path), "/system/usr/icu/"); return path; #else // But fallback to the source directory if needed. snprintf(path, sizeof(path), "%sout%s", ctest_dataSrcDir(), U_FILE_SEP_STRING); return path; #endif } const char* T_CTEST_EXPORT2 ctest_testDataDir(void) { static char path[PATH_MAX]; if (path[0]) { return path; } snprintf(path, sizeof(path), "%stest%stestdata%s", ctest_icuSrcDir(), U_FILE_SEP_STRING, U_FILE_SEP_STRING); return path; } const char* T_CTEST_EXPORT2 ctest_loadTestData(UErrorCode* err) { static char path[PATH_MAX]; if (path[0]) { return path; } snprintf(path, sizeof(path), "%sout%stestdata", ctest_testDataDir(), U_FILE_SEP_STRING); UResourceBundle* test = ures_open(path, "testtypes", err); if (U_FAILURE(*err)) { *err = U_FILE_ACCESS_ERROR; log_data_err( "Could not load testtypes.res in testdata bundle with path %s - " "%s\n", path, u_errorName(*err)); return ""; } ures_close(test); return path; }