1260 lines
33 KiB
C
1260 lines
33 KiB
C
/*
|
|
********************************************************************************
|
|
*
|
|
* Copyright (C) 1996-2010, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*
|
|
********************************************************************************
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#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"
|
|
|
|
/* 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
|
|
|
|
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);
|
|
|
|
/**
|
|
* 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 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. */
|
|
int32_t ALLOCATION_COUNT = 0;
|
|
static const char *ARGV_0 = "[ALL]";
|
|
static const char *XML_FILE_NAME=NULL;
|
|
static char XML_PREFIX[256];
|
|
|
|
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
|
|
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-(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 (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]);
|
|
}
|
|
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++;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
void T_CTEST_EXPORT2
|
|
log_err_status(UErrorCode status, const char* pattern, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, pattern);
|
|
|
|
first_line_err();
|
|
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) {
|
|
/* 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 {
|
|
/* 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;
|
|
}
|
|
umtx_atomic_inc(&ALLOCATION_COUNT);
|
|
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;
|
|
}
|
|
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);
|
|
}
|
|
|
|
int T_CTEST_EXPORT2
|
|
initArgs( int argc, const char* const argv[], ArgHandlerPtr argHandler, void *context)
|
|
{
|
|
int i;
|
|
int doList = FALSE;
|
|
int argSkip = 0;
|
|
|
|
VERBOSITY = FALSE;
|
|
ERR_MSG = TRUE;
|
|
|
|
ARGV_0=argv[0];
|
|
|
|
for( i=1; i<argc; i++)
|
|
{
|
|
if ( argv[i][0] == '/' )
|
|
{
|
|
/* We don't run the tests here. */
|
|
continue;
|
|
}
|
|
else if ((strcmp( argv[i], "-a") == 0) || (strcmp(argv[i],"-all") == 0))
|
|
{
|
|
/* We don't run the tests here. */
|
|
continue;
|
|
}
|
|
else if (strcmp( argv[i], "-v" )==0 || strcmp( argv[i], "-verbose")==0)
|
|
{
|
|
VERBOSITY = TRUE;
|
|
}
|
|
else if (strcmp( argv[i], "-l" )==0 )
|
|
{
|
|
doList = TRUE;
|
|
}
|
|
else if (strcmp( argv[i], "-e1") == 0)
|
|
{
|
|
QUICK = -1;
|
|
}
|
|
else if (strcmp( argv[i], "-e") ==0)
|
|
{
|
|
QUICK = 0;
|
|
}
|
|
else if (strcmp( argv[i], "-w") ==0)
|
|
{
|
|
WARN_ON_MISSING_DATA = TRUE;
|
|
}
|
|
else if (strcmp( argv[i], "-m") ==0)
|
|
{
|
|
UErrorCode errorCode = U_ZERO_ERROR;
|
|
if (i+1 < argc) {
|
|
char *endPtr = NULL;
|
|
i++;
|
|
MINIMUM_MEMORY_SIZE_FAILURE = (size_t)strtol(argv[i], &endPtr, 10);
|
|
if (endPtr == argv[i]) {
|
|
printf("Can't parse %s\n", argv[i]);
|
|
help(argv[0]);
|
|
return 0;
|
|
}
|
|
if (*endPtr == '-') {
|
|
char *maxPtr = endPtr+1;
|
|
endPtr = NULL;
|
|
MAXIMUM_MEMORY_SIZE_FAILURE = (size_t)strtol(maxPtr, &endPtr, 10);
|
|
if (endPtr == argv[i]) {
|
|
printf("Can't parse %s\n", argv[i]);
|
|
help(argv[0]);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
/* Use the default value */
|
|
u_setMemoryFunctions(NULL, ctest_libMalloc, ctest_libRealloc, ctest_libFree, &errorCode);
|
|
if (U_FAILURE(errorCode)) {
|
|
printf("u_setMemoryFunctions returned %s\n", u_errorName(errorCode));
|
|
return 0;
|
|
}
|
|
}
|
|
else if(strcmp( argv[i], "-n") == 0 || strcmp( argv[i], "-no_err_msg") == 0)
|
|
{
|
|
ERR_MSG = FALSE;
|
|
}
|
|
else if (strcmp( argv[i], "-r") == 0)
|
|
{
|
|
if (!REPEAT_TESTS_INIT) {
|
|
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;
|
|
}
|
|
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 errorCount = 0;
|
|
|
|
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] == '/' )
|
|
{
|
|
printf("Selecting subtree '%s'\n", argv[i]);
|
|
|
|
if ( argv[i][1] == 0 )
|
|
toRun = root;
|
|
else
|
|
toRun = getTest(root, argv[i]);
|
|
|
|
if ( toRun == NULL )
|
|
{
|
|
printf("* Could not find any matching subtree\n");
|
|
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;
|
|
} else if ((strcmp( argv[i], "-a") == 0) || (strcmp(argv[i],"-all") == 0)) {
|
|
subtreeOptionSeen=FALSE;
|
|
} else if (strcmp( argv[i], "-l") == 0) {
|
|
doList = TRUE;
|
|
}
|
|
/* else option already handled by initArgs */
|
|
}
|
|
|
|
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;
|
|
}
|
|
else
|
|
{
|
|
if( ( doList == FALSE ) && ( errorCount > 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(" -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 = 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(*rootName)) {
|
|
rootName++;
|
|
}
|
|
strcpy(XML_PREFIX,rootName);
|
|
{
|
|
char *p = XML_PREFIX+strlen(XML_PREFIX);
|
|
for(p--;*p&&p>XML_PREFIX&&!isalnum(*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 *time, 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, time);
|
|
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;
|
|
}
|
|
|
|
|