void RBBIAPITest::RoundtripRule(const char *dataFile) { UErrorCode status = U_ZERO_ERROR; UParseError parseError; parseError.line = 0; parseError.offset = 0; LocalUDataMemoryPointer data(udata_open(U_ICUDATA_BRKITR, "brk", dataFile, &status)); uint32_t length; const UChar *builtSource; const uint8_t *rbbiRules; const uint8_t *builtRules; if (U_FAILURE(status)) { errcheckln(status, "Can't open \"%s\" - %s", dataFile, u_errorName(status)); return; } builtRules = (const uint8_t *)udata_getMemory(data.getAlias()); builtSource = (const UChar *)(builtRules + ((RBBIDataHeader*)builtRules)->fRuleSource); RuleBasedBreakIterator *brkItr = new RuleBasedBreakIterator(builtSource, parseError, status); if (U_FAILURE(status)) { errln("createRuleBasedBreakIterator: ICU Error \"%s\" at line %d, column %d\n", u_errorName(status), parseError.line, parseError.offset); return; }; rbbiRules = brkItr->getBinaryRules(length); logln("Comparing \"%s\" len=%d", dataFile, length); if (memcmp(builtRules, rbbiRules, (int32_t)length) != 0) { errln("Built rules and rebuilt rules are different %s", dataFile); return; } delete brkItr; }
DictionaryMatcher * ICULanguageBreakFactory::loadDictionaryMatcherFor(UScriptCode script, int32_t /* brkType */) { UErrorCode status = U_ZERO_ERROR; // open root from brkitr tree. UResourceBundle *b = ures_open(U_ICUDATA_BRKITR, "", &status); b = ures_getByKeyWithFallback(b, "dictionaries", b, &status); int32_t dictnlength = 0; const UChar *dictfname = ures_getStringByKeyWithFallback(b, uscript_getShortName(script), &dictnlength, &status); if (U_FAILURE(status)) { ures_close(b); return NULL; } CharString dictnbuf; CharString ext; const UChar *extStart = u_memrchr(dictfname, 0x002e, dictnlength); // last dot if (extStart != NULL) { int32_t len = (int32_t)(extStart - dictfname); ext.appendInvariantChars(UnicodeString(FALSE, extStart + 1, dictnlength - len - 1), status); dictnlength = len; } dictnbuf.appendInvariantChars(UnicodeString(FALSE, dictfname, dictnlength), status); ures_close(b); UDataMemory *file = udata_open(U_ICUDATA_BRKITR, ext.data(), dictnbuf.data(), &status); if (U_SUCCESS(status)) { // build trie const uint8_t *data = (const uint8_t *)udata_getMemory(file); const int32_t *indexes = (const int32_t *)data; const int32_t offset = indexes[DictionaryData::IX_STRING_TRIE_OFFSET]; const int32_t trieType = indexes[DictionaryData::IX_TRIE_TYPE] & DictionaryData::TRIE_TYPE_MASK; DictionaryMatcher *m = NULL; if (trieType == DictionaryData::TRIE_TYPE_BYTES) { const int32_t transform = indexes[DictionaryData::IX_TRANSFORM]; const char *characters = (const char *)(data + offset); m = new BytesDictionaryMatcher(characters, transform, file); } else if (trieType == DictionaryData::TRIE_TYPE_UCHARS) { const UChar *characters = (const UChar *)(data + offset); m = new UCharsDictionaryMatcher(characters, file); } if (m == NULL) { // no matcher exists to take ownership - either we are an invalid // type or memory allocation failed udata_close(file); } return m; } else if (dictfname != NULL) { // we don't have a dictionary matcher. // returning NULL here will cause us to fail to find a dictionary break engine, as expected status = U_ZERO_ERROR; return NULL; } return NULL; }
const CompactTrieDictionary * ICULanguageBreakFactory::loadDictionaryFor(UScriptCode script, int32_t /*breakType*/) { UErrorCode status = U_ZERO_ERROR; // Open root from brkitr tree. char dictnbuff[256]; char ext[4]={'\0'}; UResourceBundle *b = ures_open(U_ICUDATA_BRKITR, "", &status); b = ures_getByKeyWithFallback(b, "dictionaries", b, &status); b = ures_getByKeyWithFallback(b, uscript_getShortName(script), b, &status); int32_t dictnlength = 0; const UChar *dictfname = ures_getString(b, &dictnlength, &status); if (U_SUCCESS(status) && (size_t)dictnlength >= sizeof(dictnbuff)) { dictnlength = 0; status = U_BUFFER_OVERFLOW_ERROR; } if (U_SUCCESS(status) && dictfname) { UChar* extStart=u_strchr(dictfname, 0x002e); int len = 0; if(extStart!=NULL){ len = extStart-dictfname; u_UCharsToChars(extStart+1, ext, sizeof(ext)); // nul terminates the buff u_UCharsToChars(dictfname, dictnbuff, len); } dictnbuff[len]=0; // nul terminate } ures_close(b); UDataMemory *file = udata_open(U_ICUDATA_BRKITR, ext, dictnbuff, &status); if (U_SUCCESS(status)) { const CompactTrieDictionary *dict = new CompactTrieDictionary( file, status); if (U_SUCCESS(status) && dict == NULL) { status = U_MEMORY_ALLOCATION_ERROR; } if (U_FAILURE(status)) { delete dict; dict = NULL; } return dict; } else if (dictfname != NULL){ //create dummy dict if dictionary filename not valid UChar c = 0x0020; status = U_ZERO_ERROR; MutableTrieDictionary *mtd = new MutableTrieDictionary(c, status, TRUE); mtd->addWord(&c, 1, status, 1); return new CompactTrieDictionary(*mtd, status); } return NULL; }
// // SpoofData::getDefault() - return a wrapper around the spoof data that is // baked into the default ICU data. // SpoofData *SpoofData::getDefault(UErrorCode &status) { // TODO: Cache it. Lazy create, keep until cleanup. UDataMemory *udm = udata_open(NULL, "cfu", "confusables", &status); if (U_FAILURE(status)) { return NULL; } SpoofData *This = new SpoofData(udm, status); if (U_FAILURE(status)) { delete This; return NULL; } if (This == NULL) { status = U_MEMORY_ALLOCATION_ERROR; } return This; }
static void TestSwapData() { char name[100]; UDataMemory *pData; uint8_t *buffer; const char *pkg, *nm; UErrorCode errorCode; int32_t i; buffer=(uint8_t *)uprv_malloc(2*SWAP_BUFFER_SIZE); if(buffer==NULL) { log_err("unable to allocate %d bytes\n", 2*SWAP_BUFFER_SIZE); return; } for(i=0; i<LENGTHOF(swapCases); ++i) { /* build the name for logging */ errorCode=U_ZERO_ERROR; if(swapCases[i].name[0]=='*') { pkg=loadTestData(&errorCode); nm=swapCases[i].name+1; uprv_strcpy(name, "testdata"); } else { pkg=NULL; nm=swapCases[i].name; uprv_strcpy(name, "NULL"); } uprv_strcat(name, "/"); uprv_strcat(name, nm); uprv_strcat(name, "."); uprv_strcat(name, swapCases[i].type); pData=udata_open(pkg, swapCases[i].type, nm, &errorCode); if(U_SUCCESS(errorCode)) { TestSwapCase(pData, name, swapCases[i].swapFn, buffer, buffer+SWAP_BUFFER_SIZE); udata_close(pData); } else { log_data_err("udata_open(%s) failed - %s\n", name, u_errorName(errorCode)); } } uprv_free(buffer); }
U_NAMESPACE_BEGIN // ------------------------------------- BreakIterator* BreakIterator::buildInstance(const Locale& loc, const char *type, int32_t kind, UErrorCode &status) { char fnbuff[256]; char ext[4]={'\0'}; char actualLocale[ULOC_FULLNAME_CAPACITY]; int32_t size; const UChar* brkfname = NULL; UResourceBundle brkRulesStack; UResourceBundle brkNameStack; UResourceBundle *brkRules = &brkRulesStack; UResourceBundle *brkName = &brkNameStack; RuleBasedBreakIterator *result = NULL; if (U_FAILURE(status)) return NULL; ures_initStackObject(brkRules); ures_initStackObject(brkName); // Get the locale UResourceBundle *b = ures_open(U_ICUDATA_BRKITR, loc.getName(), &status); /* this is a hack for now. Should be fixed when the data is fetched from brk_index.txt */ if(status==U_USING_DEFAULT_WARNING){ status=U_ZERO_ERROR; ures_openFillIn(b, U_ICUDATA_BRKITR, "", &status); } // Get the "boundaries" array. if (U_SUCCESS(status)) { brkRules = ures_getByKeyWithFallback(b, "boundaries", brkRules, &status); // Get the string object naming the rules file brkName = ures_getByKeyWithFallback(brkRules, type, brkName, &status); // Get the actual string brkfname = ures_getString(brkName, &size, &status); U_ASSERT((size_t)size<sizeof(fnbuff)); if ((size_t)size>=sizeof(fnbuff)) { size=0; if (U_SUCCESS(status)) { status = U_BUFFER_OVERFLOW_ERROR; } } // Use the string if we found it if (U_SUCCESS(status) && brkfname) { uprv_strncpy(actualLocale, ures_getLocale(brkName, &status), sizeof(actualLocale)/sizeof(actualLocale[0])); UChar* extStart=u_strchr(brkfname, 0x002e); int len = 0; if(extStart!=NULL){ len = (int)(extStart-brkfname); u_UCharsToChars(extStart+1, ext, sizeof(ext)); // nul terminates the buff u_UCharsToChars(brkfname, fnbuff, len); } fnbuff[len]=0; // nul terminate } } ures_close(brkRules); ures_close(brkName); UDataMemory* file = udata_open(U_ICUDATA_BRKITR, ext, fnbuff, &status); if (U_FAILURE(status)) { ures_close(b); return NULL; } // Create a RuleBasedBreakIterator result = new RuleBasedBreakIterator(file, status); // If there is a result, set the valid locale and actual locale, and the kind if (U_SUCCESS(status) && result != NULL) { U_LOCALE_BASED(locBased, *(BreakIterator*)result); locBased.setLocaleIDs(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status), actualLocale); result->setBreakType(kind); } ures_close(b); if (U_FAILURE(status) && result != NULL) { // Sometimes redundant check, but simple delete result; return NULL; } if (result == NULL) { udata_close(file); if (U_SUCCESS(status)) { status = U_MEMORY_ALLOCATION_ERROR; } } return result; }
// Try out the RuleBasedBreakIterator constructors that take RBBIDataHeader* // (these are protected so we access them via a local class RBBIWithProtectedFunctions). // This is just a sanity check, not a thorough test (e.g. we don't check that the // first delete actually frees rulesCopy). void RBBIAPITest::TestCreateFromRBBIData() { // Get some handy RBBIData const char *brkName = "word"; // or "sent", "line", "char", etc. UErrorCode status = U_ZERO_ERROR; LocalUDataMemoryPointer data(udata_open(U_ICUDATA_BRKITR, "brk", brkName, &status)); if ( U_SUCCESS(status) ) { const RBBIDataHeader * builtRules = (const RBBIDataHeader *)udata_getMemory(data.getAlias()); uint32_t length = builtRules->fLength; RBBIWithProtectedFunctions * brkItr; // Try the memory-adopting constructor, need to copy the data first RBBIDataHeader * rulesCopy = (RBBIDataHeader *) uprv_malloc(length); if ( rulesCopy ) { uprv_memcpy( rulesCopy, builtRules, length ); brkItr = new RBBIWithProtectedFunctions(rulesCopy, status); if ( U_SUCCESS(status) ) { delete brkItr; // this should free rulesCopy } else { errln("create RuleBasedBreakIterator from RBBIData (adopted): ICU Error \"%s\"\n", u_errorName(status) ); status = U_ZERO_ERROR;// reset for the next test uprv_free( rulesCopy ); } } // Now try the non-adopting constructor brkItr = new RBBIWithProtectedFunctions(builtRules, RBBIWithProtectedFunctions::kDontAdopt, status); if ( U_SUCCESS(status) ) { delete brkItr; // this should NOT attempt to free builtRules if (builtRules->fLength != length) { // sanity check errln("create RuleBasedBreakIterator from RBBIData (non-adopted): delete affects data\n" ); } } else { errln("create RuleBasedBreakIterator from RBBIData (non-adopted): ICU Error \"%s\"\n", u_errorName(status) ); } } // getBinaryRules() and RuleBasedBreakIterator(uint8_t binaryRules, ...) // status = U_ZERO_ERROR; RuleBasedBreakIterator *rb = (RuleBasedBreakIterator *)BreakIterator::createWordInstance(Locale::getEnglish(), status); if (rb == NULL || U_FAILURE(status)) { dataerrln("Unable to create BreakIterator::createWordInstance (Locale::getEnglish) - %s", u_errorName(status)); } else { uint32_t length; const uint8_t *rules = rb->getBinaryRules(length); RuleBasedBreakIterator *rb2 = new RuleBasedBreakIterator(rules, length, status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT(*rb == *rb2); UnicodeString words = "one two three "; rb2->setText(words); int wordCounter = 0; while (rb2->next() != UBRK_DONE) { wordCounter++; } TEST_ASSERT(wordCounter == 6); status = U_ZERO_ERROR; RuleBasedBreakIterator *rb3 = new RuleBasedBreakIterator(rules, length-1, status); TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR); delete rb; delete rb2; delete rb3; } }
static int t_rulebasedbreakiterator_init(t_rulebasedbreakiterator *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; charsArg path, name; switch (PyTuple_Size(args)) { case 0: self->object = new RuleBasedBreakIterator(); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "S", &u, &_u)) { RuleBasedBreakIterator *iterator; INT_STATUS_PARSER_CALL(iterator = new RuleBasedBreakIterator(*u, parseError, status)); self->object = iterator; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArg(args, "fn", &path, &name)) { RuleBasedBreakIterator *iterator; UDataMemory *data; UErrorCode status; status = U_ZERO_ERROR; data = udata_open(path, NULL, name, &status); if (U_FAILURE(status)) { ICUException(status).reportError(); return -1; } status = U_ZERO_ERROR; iterator = new RuleBasedBreakIterator(data, status); if (U_FAILURE(status)) { udata_close(data); ICUException(status).reportError(); return -1; } self->object = iterator; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; }
static void TestUDataOpen(){ UDataMemory *result; UErrorCode status=U_ZERO_ERROR; const char* memMap[][2]={ {"root", "res"}, {"unorm", "icu"}, {"cnvalias", "icu"}, {"unames", "icu"}, {"ibm-37_P100-1995", "cnv"} }; const char* name = "test"; const char* type = "icu"; const char dirSepString[] = {U_FILE_SEP_CHAR, 0}; const char pathSepString[] = {U_PATH_SEP_CHAR, 0}; char* path=(char*)malloc(sizeof(char) * (strlen(ctest_dataOutDir()) + strlen(U_ICUDATA_NAME) + strlen("/build")+1 ) ); char *icuDataFilePath = 0; struct stat stat_buf; const char* testPath=loadTestData(&status); /* lots_of_mallocs(); */ strcat(strcpy(path, ctest_dataOutDir()), U_ICUDATA_NAME); log_verbose("Testing udata_open()\n"); result=udata_open(testPath, type, name, &status); if(U_FAILURE(status)){ log_err("FAIL: udata_open() failed for path = %s, name=%s, type=%s, \n errorcode=%s\n", testPath, name, type, myErrorName(status)); } else { log_verbose("PASS: udata_open worked\n"); udata_close(result); } /* If the ICU system common data file is present in this confiugration, * verify that udata_open can explicitly fetch items from it. * If packaging mode == dll, the file may not exist. So, if the file is * missing, skip this test without error. */ icuDataFilePath = (char *)malloc(strlen(path) + 10); strcpy(icuDataFilePath, path); strcat(icuDataFilePath, ".dat"); /* lots_of_mallocs(); */ if (stat(icuDataFilePath, &stat_buf) == 0) { int i; log_verbose("Testing udata_open() on %s\n", icuDataFilePath); for(i=0; i<sizeof(memMap)/sizeof(memMap[0]); i++){ /* lots_of_mallocs(); */ status=U_ZERO_ERROR; result=udata_open(path, memMap[i][1], memMap[i][0], &status); if(U_FAILURE(status)) { log_data_err("FAIL: udata_open() failed for path = %s, name=%s, type=%s, \n errorcode=%s\n", path, memMap[i][0], memMap[i][1], myErrorName(status)); } else { log_verbose("PASS: udata_open worked for path = %s, name=%s, type=%s\n", path, memMap[i][0], memMap[i][1]); udata_close(result); } } } else { /* lots_of_mallocs(); */ log_verbose("Skipping tests of udata_open() on %s. File not present in this configuration.\n", icuDataFilePath); } free(icuDataFilePath); icuDataFilePath = NULL; /* lots_of_mallocs(); */ /* If the ICU individual files used to build the ICU system common data are * present in this configuration, * verify that udata_open can explicitly open them. * These data files are present in the ICU data/build directory after a build * completes. Tests are most commonly run with the data directory pointing * back into this directory structure, but this is not required. Soooo, if * the files are missing, skip this test without error. */ /* lots_of_mallocs(); */ icuDataFilePath = (char *)malloc(strlen(ctest_dataOutDir()) + 50); strcpy(icuDataFilePath, ctest_dataOutDir()); strcat(icuDataFilePath, "build"); strcat(icuDataFilePath, dirSepString); strcat(icuDataFilePath, U_ICUDATA_NAME); strcat(icuDataFilePath, "_"); strcat(icuDataFilePath, "unorm.icu"); /* lots_of_mallocs(); */ /* if (stat(icuDataFilePath, &stat_buf) == 0)*/ { int i; log_verbose("%s exists, so..\n", icuDataFilePath); strcpy(icuDataFilePath, ctest_dataOutDir()); strcat(icuDataFilePath, "build"); strcat(icuDataFilePath, dirSepString); strcat(icuDataFilePath, U_ICUDATA_NAME); log_verbose("Testing udata_open() on %s\n", icuDataFilePath); for(i=0; i<sizeof(memMap)/sizeof(memMap[0]); i++){ status=U_ZERO_ERROR; result=udata_open(icuDataFilePath, memMap[i][1], memMap[i][0], &status); if(U_FAILURE(status)) { log_data_err("FAIL: udata_open() failed for path = %s, name=%s, type=%s, \n errorcode=%s\n", icuDataFilePath, memMap[i][0], memMap[i][1], myErrorName(status)); } else { log_verbose("PASS: udata_open worked for path = %s, name=%s, type=%s\n", icuDataFilePath, memMap[i][0], memMap[i][1]); udata_close(result); } } } /* else { log_verbose("Skipping tests of udata_open() on %s. File not present in this configuration.\n", icuDataFilePath); }*/ free(icuDataFilePath); icuDataFilePath = NULL; /* * Test fallback file names for open of separate data files. * With these params to udata_open: * path = wherever/testdata * type = typ * name = nam * these files will be tried first: * wherever/testudata_nam.typ * testudata_nam.typ * A test data file named testudata_nam.typ exists for the purpose of testing this. */ log_verbose("Testing udata_open, with base_name.type style fallback to individual file.\n"); status = U_ZERO_ERROR; result = udata_open( testPath, "typ", "nam", &status); if (status != U_ZERO_ERROR) { log_err("FAIL: udata_open( \"%s\", \"typ\", \"nam\") returned status %s\n", testPath, u_errorName(status)); } udata_close(result); free(icuDataFilePath); /* This type of path is deprecated */ /* * Another fallback test. Paths ending with a trailing directory separator * take a slightly different code path, with the "base name" from the path * being empty in the internal udata_open logic. */ /* log_verbose("Testing udata_open, with path containing a trailing directory separator.\n"); */ /* icuDataFilePath = (char *)malloc(strlen(u_getDataDirectory()) + 50); */ /* strcpy(icuDataFilePath, testPath); */ /* status = U_ZERO_ERROR; */ /* result = udata_open( icuDataFilePath, "cnv", "test1", &status); */ /* if (status != U_ZERO_ERROR) { */ /* log_err("FAIL: udata_open( \"%s\", \"cnv\", \"test1\") returned status %s\n", icuDataFilePath, u_errorName(status)); */ /* } */ /* udata_close(result); */ /* free(icuDataFilePath); */ log_verbose("Testing udata_open() with a non existing binary file\n"); result=udata_open("testdata", "tst", "nonexist", &status); if(status==U_FILE_ACCESS_ERROR){ log_verbose("Opening udata_open with non-existing file handled correctly.\n"); status=U_ZERO_ERROR; } else { log_err("calling udata_open with non-existing file [testdata | nonexist.tst] not handled correctly\n. Expected: U_FILE_ACCESS_ERROR, Got: %s\n", myErrorName(status)); if(U_SUCCESS(status)) { udata_close(result); } } if(result != NULL){ log_err("calling udata_open with non-existing file didn't return a null value\n"); } else { log_verbose("calling udat_open with non-existing file returned null as expected\n"); } /* * Try opening data with absurdly long path and name, to trigger buffer size * overflow handling code. */ { char longTestPath[1024]; /* Implementation goes to heap at length of 128. */ char longName[1024]; /* Try a very long nonexistent directory path. * udata_open should still succeed. Opening with the path will fail, * then fall back to skipping the directory portion of the path. */ log_verbose("Testing udata_open() with really long names\n"); longTestPath[0] = 0; strcat(longTestPath, "bogus_directory_name"); while (strlen(longTestPath) < 500) { strcat(longTestPath, dirSepString); strcat(longTestPath, "bogus_directory_name"); } strcat(longTestPath, pathSepString); strcat(longTestPath, testPath); result=udata_open(longTestPath, type, name, &status); if(U_FAILURE(status)){ log_err("FAIL: udata_open() failed for path = %s\n name=%s, type=%s, \n errorcode=%s\n", longTestPath, name, type, myErrorName(status)); } else { log_verbose("PASS: udata_open worked\n"); udata_close(result); } /* Try a very long name. Won't open, but shouldn't blow up. */ longName[0] = 0; while (strlen(longName) < 500) { strcat(longName, name); strcat(longName, "_"); } strcat(longName, dirSepString); strcat(longName, name); result=udata_open(longTestPath, type, longName, &status); if (status != U_FILE_ACCESS_ERROR) { log_err("FAIL: udata_open() failed for path = %s\n name=%s, type=%s, \n errorcode=%s\n", longTestPath, longName, type, myErrorName(status)); } udata_close(result); } free(path); }
static void TestErrorConditions(){ UDataMemory *result=NULL; UErrorCode status=U_ZERO_ERROR; uint16_t* intValue=0; static UDataInfo dataInfo={ 30, /*sizeof(UDataInfo),*/ 0, U_IS_BIG_ENDIAN, U_CHARSET_FAMILY, sizeof(UChar), 0, {0x54, 0x65, 0x73, 0x74}, /* dataFormat="Test" */ {9, 0, 0, 0}, /* formatVersion */ {4, 0, 0, 0} /* dataVersion */ }; const char* name = "test"; const char* type="icu"; const char *testPath = loadTestData(&status); status = U_ILLEGAL_ARGUMENT_ERROR; /*Try udata_open with status != U_ZERO_ERROR*/ log_verbose("Testing udata_open() with status != U_ZERO_ERROR\n"); result=udata_open(testPath, type, name, &status); if(result != NULL){ log_err("FAIL: udata_open() is supposed to fail for path = %s, name=%s, type=%s, \n errorcode !=U_ZERO_ERROR\n", testPath, name, type); udata_close(result); } else { log_verbose("PASS: udata_open with errorCode != U_ZERO_ERROR failed as expected\n"); } /*Try udata_open with data name=NULL*/ log_verbose("Testing udata_open() with data name=NULL\n"); status=U_ZERO_ERROR; result=udata_open(testPath, type, NULL, &status); if(U_FAILURE(status)){ if(status != U_ILLEGAL_ARGUMENT_ERROR || result != NULL){ log_err("FAIL: udata_open() with name=NULL should return NULL and errocode U_ILLEGAL_ARGUMENT_ERROR, GOT: errorcode=%s\n", myErrorName(status)); }else{ log_verbose("PASS: udata_open with name=NULL failed as expected and errorcode = %s as expected\n", myErrorName(status)); } }else{ log_err("FAIL: udata_open() with data name=NULL is supposed to fail for path = %s, name=NULL type=%s errorcode=U_ZERO_ERROR \n", testPath, type); udata_close(result); } /*Try udata_openChoice with status != U_ZERO_ERROR*/ log_verbose("Testing udata_openChoice() with status != U_ZERO_ERROR\n"); status=U_ILLEGAL_ARGUMENT_ERROR; result=udata_openChoice(testPath, type, name, isAcceptable3, NULL, &status); if(result != NULL){ log_err("FAIL: udata_openChoice() is supposed to fail for path = %s, name=%s, type=%s, \n errorcode != U_ZERO_ERROR\n", testPath, name, type); udata_close(result); } else { log_verbose("PASS: udata_openChoice() with errorCode != U_ZERO_ERROR failed as expected\n"); } /*Try udata_open with data name=NULL*/ log_verbose("Testing udata_openChoice() with data name=NULL\n"); status=U_ZERO_ERROR; result=udata_openChoice(testPath, type, NULL, isAcceptable3, NULL, &status); if(U_FAILURE(status)){ if(status != U_ILLEGAL_ARGUMENT_ERROR || result != NULL){ log_err("FAIL: udata_openChoice() with name=NULL should return NULL and errocode U_ILLEGAL_ARGUMENT_ERROR, GOT: errorcode=%s\n", myErrorName(status)); }else{ log_verbose("PASS: udata_openChoice with name=NULL failed as expected and errorcode = %s as expected\n", myErrorName(status)); } }else{ log_err("FAIL: udata_openChoice() with data name=NULL is supposed to fail for path = %s, name=NULL type=%s errorcode=U_ZERO_ERROR \n", testPath, type); udata_close(result); } /*Try udata_getMemory with UDataMemory=NULL*/ log_verbose("Testing udata_getMemory with UDataMemory=NULL\n"); intValue=(uint16_t*)udata_getMemory(NULL); if(intValue != NULL){ log_err("FAIL: udata_getMemory with UDataMemory = NULL is supposed to fail\n"); } /*Try udata_getInfo with UDataMemory=NULL*/ status=U_ZERO_ERROR; udata_getInfo(NULL, &dataInfo); if(dataInfo.size != 0){ log_err("FAIL : udata_getInfo with UDataMemory = NULL us supposed to fail\n"); } /*Try udata_openChoice with a non existing binary file*/ log_verbose("Testing udata_openChoice() with a non existing binary file\n"); result=udata_openChoice(testPath, "tst", "nonexist", isAcceptable3, NULL, &status); if(status==U_FILE_ACCESS_ERROR){ log_verbose("Opening udata_openChoice with non-existing file handled correctly.\n"); status=U_ZERO_ERROR; } else { log_err("calling udata_open with non-existing file not handled correctly\n. Expected: U_FILE_ACCESS_ERROR, Got: %s\n", myErrorName(status)); if(U_SUCCESS(status)) { udata_close(result); } } if(result != NULL){ log_err("calling udata_open with non-existing file didn't return a null value\n"); } else { log_verbose("calling udat_open with non-existing file returned null as expected\n"); } }
static void TestUDataGetInfo() { UDataMemory *result; /* UDataInfo cf. udata.h */ static UDataInfo dataInfo={ 30, /*sizeof(UDataInfo),*/ 0, U_IS_BIG_ENDIAN, U_CHARSET_FAMILY, sizeof(UChar), 0, {0x54, 0x65, 0x73, 0x74}, /* dataFormat="Test" */ {9, 0, 0, 0}, /* formatVersion */ {4, 0, 0, 0} /* dataVersion */ }; UErrorCode status=U_ZERO_ERROR; const char* name="cnvalias"; const char* name2="test"; const char* type="icu"; const char* testPath=loadTestData(&status); log_verbose("Testing udata_getInfo() for cnvalias.icu\n"); result=udata_open(NULL, "icu", name, &status); if(U_FAILURE(status)){ log_err("FAIL: udata_open() failed for path = NULL, name=%s, type=%s, \n errorcode=%s\n", name, type, myErrorName(status)); return; } udata_getInfo(result, &dataInfo); if(dataInfo.size==20 && dataInfo.size!=30 && dataInfo.isBigEndian==U_IS_BIG_ENDIAN && dataInfo.charsetFamily==U_CHARSET_FAMILY && dataInfo.dataFormat[0]==0x43 && dataInfo.dataFormat[0]!=0x54 && /* dataFormat="CvAl" and not "Test". The values are set for cnvalias.dat*/ dataInfo.dataFormat[1]==0x76 && dataInfo.dataFormat[1]!=0x65 && dataInfo.dataFormat[2]==0x41 && dataInfo.dataFormat[2]!=0x73 && dataInfo.dataFormat[3]==0x6c && dataInfo.dataFormat[3]!=0x74 && dataInfo.formatVersion[0]!=9 && /*formatVersion is also set to the one for cnvalias*/ dataInfo.dataVersion[0]!=4 && /*dataVersion*/ dataInfo.dataVersion[1]!=0 ){ log_verbose("PASS: udata_getInfo() filled in the right values\n"); } else { log_err("FAIL: udata_getInfo() filled in the wrong values\n"); } udata_close(result); log_verbose("Testing udata_getInfo() for test.icu\n"); result=udata_open(testPath, type, name2, &status); if(U_FAILURE(status)) { log_err("FAIL: udata_open() failed for path=%s name2=%s, type=%s, \n errorcode=%s\n", testPath, name2, type, myErrorName(status)); return; } udata_getInfo(result, &dataInfo); if(dataInfo.size==20 && dataInfo.isBigEndian==U_IS_BIG_ENDIAN && dataInfo.charsetFamily==U_CHARSET_FAMILY && dataInfo.dataFormat[0]==0x54 && /* dataFormat="Test". The values are set for test.dat*/ dataInfo.dataFormat[1]==0x65 && dataInfo.dataFormat[2]==0x73 && dataInfo.dataFormat[3]==0x74 && dataInfo.formatVersion[0]==1 && /*formatVersion is also set to the one for test*/ dataInfo.dataVersion[0]==1 && /*dataVersion*/ dataInfo.dataVersion[1]==0 ) { log_verbose("PASS: udata_getInfo() filled in the right values\n"); } else { log_err("FAIL: udata_getInfo() filled in the wrong values\n"); } udata_close(result); }