/******************************************************************** * COPYRIGHT: * Copyright (c) 1997-2001, International Business Machines Corporation and * others. All Rights Reserved. ********************************************************************/ /******************************************************************************** * * File CINTLTST.C * * Modification History: * Name Description * Madhu Katragadda Creation ********************************************************************************* */ /*The main root for C API tests*/ #include #include #include #include "unicode/utypes.h" #include "unicode/putil.h" #include "cintltst.h" #include "umutex.h" #include "unicode/uchar.h" #include "unicode/ustring.h" #include "unicode/ucnv.h" #include "unicode/ures.h" #include "unicode/uclean.h" #ifdef XP_MAC_CONSOLE # include #endif #define CTST_LEAK_CHECK 1 #ifdef CTST_LEAK_CHECK U_CFUNC void ctst_freeAll(void); U_CFUNC void ctst_init(void); #endif static char* _testDataPath=NULL; /* * Forward Declarations */ void ctest_setICU_DATA(void); static UBool gMutexInitialized = FALSE; static TestMutex(void) { if (!gMutexInitialized) { log_err("*** Failure! The global mutex was not initialized.\n" "*** Make sure the right linker was used.\n"); } } void addSetup(TestNode** root) { addTest(root, &TestMutex, "setup/TestMutex"); } int main(int argc, const char* const argv[]) { int nerrors = 0; TestNode *root; /* initial check for the default converter */ UErrorCode errorCode = U_ZERO_ERROR; UResourceBundle *rb; UConverter *cnv; /* This must be tested before using anything! */ gMutexInitialized = umtx_isInitialized(NULL); while (REPEAT_TESTS > 0) { #ifdef CTST_LEAK_CHECK ctst_init(); #endif /* try opening the data from dll instead of the dat file */ cnv = ucnv_open("iso-8859-7", &errorCode); if(cnv != 0) { /* ok */ ucnv_close(cnv); } else { fprintf(stderr, "#### WARNING! The converter for iso-8859-7 cannot be loaded from data dll/so." "Proceeding to load data from dat file.\n"); errorCode = U_ZERO_ERROR; } /* If no ICU_DATA environment was set, try to fake up one. */ ctest_setICU_DATA(); #ifdef XP_MAC_CONSOLE argc = ccommand((char***)&argv); #endif cnv = ucnv_open(NULL, &errorCode); if(cnv != NULL) { /* ok */ ucnv_close(cnv); } else { fprintf(stderr, "*** Failure! The default converter cannot be opened.\n" "*** Check the ICU_DATA environment variable and \n" "*** check that the data files are present.\n"); return 1; } /* try more data */ cnv = ucnv_open("iso-8859-7", &errorCode); if(cnv != 0) { /* ok */ ucnv_close(cnv); } else { fprintf(stderr, "*** Failure! The converter for iso-8859-7 cannot be opened.\n" "*** Check the ICU_DATA environment variable and \n" "*** check that the data files are present.\n"); return 1; } rb = ures_open(NULL, "en", &errorCode); if(U_SUCCESS(errorCode)) { /* ok */ ures_close(rb); } else { fprintf(stderr, "*** Failure! The \"en\" locale resource bundle cannot be opened.\n" "*** Check the ICU_DATA environment variable and \n" "*** check that the data files are present.\n"); return 1; } fprintf(stdout, "Default locale for this run is %s\n", uloc_getDefault()); root = NULL; addAllTests(&root); nerrors = processArgs(root, argc, argv); if (--REPEAT_TESTS > 0) { printf("Repeating tests %d more time(s)\n", REPEAT_TESTS); } cleanUpTestTree(root); #ifdef CTST_LEAK_CHECK ctst_freeAll(); /* To check for leaks */ u_cleanup(); /* nuke the hashtable.. so that any still-open cnvs are leaked */ #endif } return nerrors ? 1 : 0; } void ctest_pathnameInContext( char* fullname, int32_t maxsize, const char* relPath ) { char mainDirBuffer[1024]; char* mainDir = NULL; const char *dataDirectory = u_getDataDirectory(); const char inpSepChar = '|'; char* tmp; int32_t lenMainDir; int32_t lenRelPath; #ifdef XP_MAC Str255 volName; int16_t volNum; OSErr err = GetVol( volName, &volNum ); if (err != noErr) volName[0] = 0; mainDir = (char*) &(volName[1]); mainDir[volName[0]] = 0; #else if (dataDirectory != NULL) { strcpy(mainDirBuffer, dataDirectory); strcat(mainDirBuffer, ".." U_FILE_SEP_STRING); } else { mainDirBuffer[0]='\0'; } mainDir = mainDirBuffer; #endif lenMainDir = (int32_t)strlen(mainDir); if(lenMainDir > 0 && mainDir[lenMainDir - 1] != U_FILE_SEP_CHAR) { mainDir[lenMainDir++] = U_FILE_SEP_CHAR; mainDir[lenMainDir] = 0; } if (relPath[0] == '|') relPath++; lenRelPath = (int32_t)strlen(relPath); if (maxsize < lenMainDir + lenRelPath + 2) { fullname[0] = 0; return; } strcpy(fullname, mainDir); /*strcat(fullname, U_FILE_SEP_STRING);*/ strcat(fullname, relPath); strchr(fullname, inpSepChar); tmp = strchr(fullname, inpSepChar); while (tmp) { *tmp = U_FILE_SEP_CHAR; tmp = strchr(tmp+1, inpSepChar); } } /* ctest_setICU_DATA - if the ICU_DATA environment variable is not already * set, try to deduce the directory in which ICU was built, * and set ICU_DATA to "icu/source/data" in that location. * The intent is to allow the tests to have a good chance * of running without requiring that the user manually set * ICU_DATA. Common data isn't a problem, since it is * picked up via a static (build time) reference, but the * tests dynamically load some data. */ void ctest_setICU_DATA() { const char *original_ICU_DATA = getenv("ICU_DATA"); if (original_ICU_DATA != NULL && *original_ICU_DATA != 0) { /* If the user set ICU_DATA, don't second-guess the person. */ return; } /* U_TOPBUILDDIR 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. */ #if defined (U_TOPBUILDDIR) { static char env_string[] = U_TOPBUILDDIR U_FILE_SEP_STRING "data"U_FILE_SEP_STRING"out"U_FILE_SEP_STRING; u_setDataDirectory(env_string); return; } #else /* 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" */ { char p[sizeof(__FILE__) + 10]; 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 "data" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING); u_setDataDirectory(p); /* p is "ICU_DATA=wherever\icu\source\data" */ return; } } #endif /* No location for the data dir was identifiable. * Add other fallbacks for the test data location here if the need arises */ } char *austrdup(const UChar* unichars) { int length; char *newString; length = u_strlen ( unichars ); /*newString = (char*)malloc ( sizeof( char ) * 4 * ( length + 1 ) );*/ /* this leaks for now */ newString = (char*)ctst_malloc ( sizeof( char ) * 4 * ( length + 1 ) ); /* this shouldn't */ if ( newString == NULL ) return NULL; u_austrcpy ( newString, unichars ); return newString; } char *aescstrdup(const UChar* unichars,int32_t length){ char *newString,*targetLimit,*target; UConverterFromUCallback cb; const void *p; UErrorCode errorCode = U_ZERO_ERROR; UConverter* conv = ucnv_open("US-ASCII",&errorCode); if(length==-1){ length = u_strlen( unichars); } newString = (char*)ctst_malloc ( sizeof(char) * 8 * (length +1)); target = newString; targetLimit = newString+sizeof(char) * 8 * (length +1); ucnv_setFromUCallBack(conv, UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_JAVA, &cb, &p, &errorCode); ucnv_fromUnicode(conv,&target,targetLimit, &unichars, (UChar*)(unichars+length),NULL,TRUE,&errorCode); ucnv_close(conv); *target = '\0'; return newString; } const char* loadTestData(UErrorCode* err){ const char* directory=NULL; UResourceBundle* test =NULL; char* tdpath=NULL; const char* tdrelativepath = ".."U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING"out"U_FILE_SEP_STRING; if( _testDataPath == NULL){ directory= u_getDataDirectory(); tdpath = (char*) ctst_malloc(sizeof(char) *(( strlen(directory) * strlen(tdrelativepath)) + 10)); /* u_getDataDirectory shoul return \source\data ... set the * directory to ..\source\data\..\test\testdata\out\testdata * * Fallback: When Memory mapped file is built * ..\source\data\out\..\..\test\testdata\out\testdata */ strcpy(tdpath, directory); strcat(tdpath, tdrelativepath); strcat(tdpath,"testdata"); test=ures_open(tdpath, "testtypes", err); /* we could not find the data in tdpath * try tdpathFallback */ if(U_FAILURE(*err)) { strcpy(tdpath,directory); strcat(tdpath,".."U_FILE_SEP_STRING); strcat(tdpath, tdrelativepath); strcat(tdpath,"testdata"); *err =U_ZERO_ERROR; test=ures_open(tdpath, "testtypes", err); /* we could not find the data in tdpath * try one more tdpathFallback */ if(U_FAILURE(*err)){ strcpy(tdpath,directory); strcat(tdpath,".."U_FILE_SEP_STRING); strcat(tdpath,".."U_FILE_SEP_STRING); strcat(tdpath, tdrelativepath); strcat(tdpath,"testdata"); *err =U_ZERO_ERROR; test=ures_open(tdpath, "testtypes", err); /* Fall back did not succeed either so return */ if(U_FAILURE(*err)){ *err = U_FILE_ACCESS_ERROR; log_err("construction of NULL did not succeed : %s \n", u_errorName(*err)); return ""; } ures_close(test); _testDataPath = tdpath; return _testDataPath; } ures_close(test); _testDataPath = tdpath; return _testDataPath; } ures_close(test); _testDataPath = tdpath; return _testDataPath; } return _testDataPath; } #define CTST_MAX_ALLOC 10000 /* Array used as a queue */ static void * ctst_allocated_stuff[CTST_MAX_ALLOC]; static int ctst_allocated = 0; static UBool ctst_free = FALSE; void ctst_init(void) { int i; for(i=0; i= CTST_MAX_ALLOC - 1) { ctst_allocated = 0; ctst_free = TRUE; } if(ctst_allocated_stuff[ctst_allocated]) { free(ctst_allocated_stuff[ctst_allocated]); } return ctst_allocated_stuff[ctst_allocated++] = malloc(size); } #ifdef CTST_LEAK_CHECK void ctst_freeAll() { int i; if(ctst_free == 0) { for(i=0; i