/*
********************************************************************************
*
-* Copyright (C) 1996-2008, International Business Machines
+* Copyright (C) 1996-2013, International Business Machines
* Corporation and others. All Rights Reserved.
*
********************************************************************************
#include <string.h>
#include <assert.h>
#include <stdarg.h>
+#include <ctype.h>
#include "unicode/utrace.h"
#include "unicode/uclean.h"
-#include "umutex.h"
+#include "putilimp.h"
+#include "udbgutil.h"
/* NOTES:
3/20/1999 srl - strncpy called w/o setting nulls at the end
#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
+
struct TestNode
{
void (*test)(void);
int* nameLen,
const char** nextName );
-static void iterateTestsWithLevel( const TestNode *root, int len,
- const TestNode** list,
+static void iterateTestsWithLevel( const TestNode *root, int depth,
+ const TestNode** nodeList,
TestMode mode);
static void help ( const char *argv0 );
*/
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 */
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. */
-int32_t ALLOCATION_COUNT = 0;
+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] */
}
free(tn);
+
}
}
}
+/**
+ * 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 len,
- const TestNode** list,
+ int depth,
+ const TestNode** nodeList,
TestMode mode)
{
int i;
- int saveIndent;
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;
- list[len++] = root;
+ /* record the current root node, and increment depth. */
+ nodeList[depth++] = root;
+ /* depth is now the depth of root's children. */
- for ( i=0;i<(len-1);i++ )
+ /* Collect the 'path' to the current subtree. */
+ for ( i=0;i<(depth-1);i++ )
{
- strcat(pathToFunction, list[i]->name);
+ 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 */
- strcat(pathToFunction, list[i]->name);
- INDENT_LEVEL = len;
- if ( (mode == RUNTESTS) && (root->test != NULL))
+ 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;
- root->test();
+ 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 (myERROR_COUNT != ERROR_COUNT)
- {
-
- log_info("---[%d ERRORS] ", ERROR_COUNT - myERROR_COUNT);
- strcpy(ERROR_LOG[ERRONEOUS_FUNCTION_COUNT++], pathToFunction);
+ if((ONE_ERROR>0)&&(ERROR_COUNT==0)) {
+ ERROR_COUNT++; /* There was an error without a newline */
}
- else
- log_info("---[OK] ");
+ 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-(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. */
- saveIndent = INDENT_LEVEL;
- INDENT_LEVEL = 0;
- log_info("%s%s%c\n", (list[i]->test||mode==SHOWTESTS)?"---":"",pathToFunction, list[i]->test?' ':TEST_SEPARATOR );
- INDENT_LEVEL = saveIndent;
+ if(mode==SHOWTESTS) {
+ log_testinfo("---%s%c\n",pathToFunction, nodeList[i]->test?' ':TEST_SEPARATOR );
+ }
- iterateTestsWithLevel ( root->child, len, list, mode );
+ INDENT_LEVEL = depth;
- len--;
+ 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);
+ }
+ }
- if ( len != 0 ) /* DO NOT iterate over siblings of the root. */
- iterateTestsWithLevel ( root->sibling, len, list, mode );
+ 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 );
+ }
}
showTests ( const TestNode *root )
{
/* make up one for them */
- const TestNode *aList[MAXTESTS];
+ const TestNode *nodeList[MAXTESTS];
if (root == NULL)
log_err("TEST CAN'T BE FOUND!");
- iterateTestsWithLevel ( root, 0, aList, SHOWTESTS );
+ iterateTestsWithLevel ( root, 0, nodeList, SHOWTESTS );
}
runTests ( const TestNode *root )
{
int i;
- const TestNode *aList[MAXTESTS];
+ const TestNode *nodeList[MAXTESTS];
/* make up one for them */
log_err("TEST CAN'T BE FOUND!\n");
ERRONEOUS_FUNCTION_COUNT = ERROR_COUNT = 0;
- iterateTestsWithLevel ( root, 0, aList, RUNTESTS );
+ 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);
+ }
+
if (ERROR_COUNT)
{
- log_info("\nSUMMARY:\n******* [Total error count:\t%d]\n Errors in\n", 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++)
- log_info("[%s]\n",ERROR_LOG[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_info("\n[All tests passed successfully...]\n");
+ log_testinfo("\n[All tests passed successfully...]\n");
}
if(DATA_ERROR_COUNT) {
if(WARN_ON_MISSING_DATA==0) {
- log_info("\t*Note* some errors are data-loading related. If the data used is not the \n"
+ 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_info("\t*WARNING* some data-loading errors were ignored by the -w option.\n");
+ log_testinfo("\t*WARNING* some data-loading errors were ignored by the -w option.\n");
}
}
}
}
}
+/* =========== 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;
}
- fprintf(stderr, "%-*s", INDENT_LEVEL," " );
+ fputs("!", stdout); /* col 1 - bang */
+ fprintf(stdout, "%-*s", INDENT_LEVEL,"" );
if(prefix) {
- fputs(prefix, stderr);
+ fputs(prefix, stdout);
}
- vfprintf(stderr, pattern, ap);
- fflush(stderr);
+ 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", ticket, buf);
+ } else {
+ log_verbose("(Known issue #%s) %s", ticket, buf);
+ }
+
+ return TRUE;
+}
+
+
void T_CTEST_EXPORT2
vlog_info(const char *prefix, const char *pattern, va_list ap)
{
- fprintf(stdout, "%-*s", INDENT_LEVEL," " );
+ 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;
- fprintf(stdout, "%-*s", INDENT_LEVEL," " );
+ 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);
+ go_offline_err();
++DATA_ERROR_COUNT; /* for informational message at the end */
if(WARN_ON_MISSING_DATA == 0) {
}
vlog_err(NULL, pattern, ap); /* no need for prefix in default case */
} else {
- vlog_info("[Data] ", pattern, ap);
+ vlog_info("[DATA] ", pattern, ap);
}
}
if (MINIMUM_MEMORY_SIZE_FAILURE <= size && size <= MAXIMUM_MEMORY_SIZE_FAILURE) {
return NULL;
}
- umtx_atomic_inc(&ALLOCATION_COUNT);
return malloc(size);
}
static void *U_CALLCONV ctest_libRealloc(const void *context, void *mem, size_t size) {
/*free(mem);*/ /* Realloc doesn't free on failure. */
return NULL;
}
- if (mem == NULL) {
- /* New allocation. */
- umtx_atomic_inc(&ALLOCATION_COUNT);
- }
return realloc(mem, size);
}
static void U_CALLCONV ctest_libFree(const void *context, void *mem) {
- if (mem != NULL) {
- umtx_atomic_dec(&ALLOCATION_COUNT);
- }
free(mem);
}
initArgs( int argc, const char* const argv[], ArgHandlerPtr argHandler, void *context)
{
int i;
- int doList = FALSE;
- int argSkip = 0;
+ int argSkip = 0;
VERBOSITY = FALSE;
ERR_MSG = TRUE;
+ ARGV_0=argv[0];
+
for( i=1; i<argc; i++)
{
if ( argv[i][0] == '/' )
}
else if (strcmp( argv[i], "-l" )==0 )
{
- doList = TRUE;
+ /* doList = TRUE; */
}
else if (strcmp( argv[i], "-e1") == 0)
{
{
QUICK = 0;
}
+ else if (strcmp( argv[i], "-K") ==0)
+ {
+ NO_KNOWN = 1;
+ }
+ else if (strncmp( argv[i], "-E",2) ==0)
+ {
+ SUMMARY_FILE=argv[i]+2;
+ }
else if (strcmp( argv[i], "-w") ==0)
{
WARN_ON_MISSING_DATA = TRUE;
REPEAT_TESTS++;
}
}
+ else if (strcmp( argv[i], "-x") == 0)
+ {
+ if(++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;
}
toRun = root;
+ if(ctest_xml_init(ARGV_0)) {
+ return 1; /* couldn't fire up XML thing */
+ }
+
for( i=1; i<argc; i++)
{
if ( argv[i][0] == '/' )
return -1;
}
+ ON_LINE=FALSE; /* just in case */
+
if( doList == TRUE)
showTests(toRun);
else
runTests(toRun);
+ ON_LINE=FALSE; /* just in case */
+
errorCount += ERROR_COUNT;
subtreeOptionSeen = TRUE;
if( subtreeOptionSeen == FALSE) /* no other subtree given, run the default */
{
+ ON_LINE=FALSE; /* just in case */
if( doList == TRUE)
showTests(toRun);
else
runTests(toRun);
+ ON_LINE=FALSE; /* just in case */
errorCount += ERROR_COUNT;
}
}
REPEAT_TESTS_INIT = 1;
+
+ if(ctest_xml_fini()) {
+ errorCount++;
+ }
return errorCount; /* total error count */
}
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(" 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, "<testsuite name=\"%s\">\n", XML_PREFIX);
+
+ return 0;
+}
+
+int32_t
+T_CTEST_EXPORT2
+ctest_xml_fini(void) {
+ if(!XML_FILE) return 0;
+
+ fprintf(XML_FILE, "</testsuite>\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<testcase classname=\"%s:%s\" name=\"%s:%s\" time=\"%s\"", XML_PREFIX, classname, XML_PREFIX, name, timeSeconds);
+ if(failMsg) {
+ fprintf(XML_FILE, ">\n\t\t<failure type=\"err\" message=\"%s\"/>\n\t</testcase>\n", failMsg);
+ } else {
+ fprintf(XML_FILE, "/>\n");
+ }
+
+ return 0;
+}
+
+
projects / apple / icu.git / blobdiff