/* * Spoof Detction C API Tests */ static void TestUSpoofCAPI(void) { /* * basic uspoof_open(). */ { USpoofChecker *sc; UErrorCode status = U_ZERO_ERROR; sc = uspoof_open(&status); TEST_ASSERT_SUCCESS(status); if (U_FAILURE(status)) { /* If things are so broken that we can't even open a default spoof checker, */ /* don't even try the rest of the tests. They would all fail. */ return; } uspoof_close(sc); } /* * Test Open from source rules. */ TEST_SETUP const char *dataSrcDir; char *fileName; char *confusables; int confusablesLength; char *confusablesWholeScript; int confusablesWholeScriptLength; FILE *f; UParseError pe; int32_t errType; USpoofChecker *rsc; dataSrcDir = ctest_dataSrcDir(); fileName = malloc(strlen(dataSrcDir) + 100); strcpy(fileName, dataSrcDir); strcat(fileName, U_FILE_SEP_STRING "unidata" U_FILE_SEP_STRING "confusables.txt"); f = fopen(fileName, "r"); TEST_ASSERT_NE(f, NULL); confusables = malloc(3000000); confusablesLength = fread(confusables, 1, 3000000, f); fclose(f); strcpy(fileName, dataSrcDir); strcat(fileName, U_FILE_SEP_STRING "unidata" U_FILE_SEP_STRING "confusablesWholeScript.txt"); f = fopen(fileName, "r"); TEST_ASSERT_NE(f, NULL); confusablesWholeScript = malloc(1000000); confusablesWholeScriptLength = fread(confusablesWholeScript, 1, 1000000, f); fclose(f); rsc = uspoof_openFromSource(confusables, confusablesLength, confusablesWholeScript, confusablesWholeScriptLength, &errType, &pe, &status); TEST_ASSERT_SUCCESS(status); free(confusablesWholeScript); free(confusables); free(fileName); uspoof_close(rsc); /* printf("ParseError Line is %d\n", pe.line); */ TEST_TEARDOWN; /* * openFromSerialized and serialize */ TEST_SETUP int32_t serializedSize = 0; int32_t actualLength = 0; char *buf; USpoofChecker *sc2; int32_t checkResults; serializedSize = uspoof_serialize(sc, NULL, 0, &status); TEST_ASSERT_EQ(status, U_BUFFER_OVERFLOW_ERROR); TEST_ASSERT(serializedSize > 0); /* Serialize the default spoof checker */ status = U_ZERO_ERROR; buf = (char *)malloc(serializedSize + 10); TEST_ASSERT(buf != NULL); buf[serializedSize] = 42; uspoof_serialize(sc, buf, serializedSize, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(42, buf[serializedSize]); /* Create a new spoof checker from the freshly serialized data */ sc2 = uspoof_openFromSerialized(buf, serializedSize+10, &actualLength, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_NE(NULL, sc2); TEST_ASSERT_EQ(serializedSize, actualLength); /* Verify that the new spoof checker at least wiggles */ checkResults = uspoof_check(sc2, goodLatin, -1, NULL, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(0, checkResults); checkResults = uspoof_check(sc2, scMixed, -1, NULL, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(USPOOF_SINGLE_SCRIPT | USPOOF_MIXED_SCRIPT_CONFUSABLE, checkResults); uspoof_close(sc2); free(buf); TEST_TEARDOWN; /* * Set & Get Check Flags */ TEST_SETUP int32_t t; uspoof_setChecks(sc, USPOOF_ALL_CHECKS, &status); TEST_ASSERT_SUCCESS(status); t = uspoof_getChecks(sc, &status); TEST_ASSERT_EQ(t, USPOOF_ALL_CHECKS); uspoof_setChecks(sc, 0, &status); TEST_ASSERT_SUCCESS(status); t = uspoof_getChecks(sc, &status); TEST_ASSERT_EQ(0, t); uspoof_setChecks(sc, USPOOF_WHOLE_SCRIPT_CONFUSABLE | USPOOF_MIXED_SCRIPT_CONFUSABLE | USPOOF_ANY_CASE, &status); TEST_ASSERT_SUCCESS(status); t = uspoof_getChecks(sc, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(USPOOF_WHOLE_SCRIPT_CONFUSABLE | USPOOF_MIXED_SCRIPT_CONFUSABLE | USPOOF_ANY_CASE, t); TEST_TEARDOWN; /* * get & setAllowedChars */ TEST_SETUP USet *us; const USet *uset; uset = uspoof_getAllowedChars(sc, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT(uset_isFrozen(uset)); us = uset_open((UChar32)0x41, (UChar32)0x5A); /* [A-Z] */ uspoof_setAllowedChars(sc, us, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_NE(us, uspoof_getAllowedChars(sc, &status)); TEST_ASSERT(uset_equals(us, uspoof_getAllowedChars(sc, &status))); TEST_ASSERT_SUCCESS(status); uset_close(us); TEST_TEARDOWN; /* * clone() */ TEST_SETUP USpoofChecker *clone1 = NULL; USpoofChecker *clone2 = NULL; int32_t checkResults = 0; clone1 = uspoof_clone(sc, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_NE(clone1, sc); clone2 = uspoof_clone(clone1, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_NE(clone2, clone1); uspoof_close(clone1); /* Verify that the cloned spoof checker is alive */ checkResults = uspoof_check(clone2, goodLatin, -1, NULL, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(0, checkResults); checkResults = uspoof_check(clone2, scMixed, -1, NULL, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(USPOOF_SINGLE_SCRIPT | USPOOF_MIXED_SCRIPT_CONFUSABLE, checkResults); uspoof_close(clone2); TEST_TEARDOWN; /* * get & set Checks */ TEST_SETUP int32_t checks; int32_t checks2; int32_t checkResults; checks = uspoof_getChecks(sc, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(USPOOF_ALL_CHECKS, checks); checks &= ~(USPOOF_SINGLE_SCRIPT | USPOOF_MIXED_SCRIPT_CONFUSABLE); uspoof_setChecks(sc, checks, &status); TEST_ASSERT_SUCCESS(status); checks2 = uspoof_getChecks(sc, &status); TEST_ASSERT_EQ(checks, checks2); /* The checks that were disabled just above are the same ones that the "scMixed" test fails. So with those tests gone checking that Identifier should now succeed */ checkResults = uspoof_check(sc, scMixed, -1, NULL, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(0, checkResults); TEST_TEARDOWN; /* * AllowedLoacles */ TEST_SETUP const char *allowedLocales; int32_t checkResults; /* Default allowed locales list should be empty */ allowedLocales = uspoof_getAllowedLocales(sc, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT(strcmp("", allowedLocales) == 0) /* Allow en and ru, which should enable Latin and Cyrillic only to pass */ uspoof_setAllowedLocales(sc, "en, ru_RU", &status); TEST_ASSERT_SUCCESS(status); allowedLocales = uspoof_getAllowedLocales(sc, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT(strstr(allowedLocales, "en") != NULL); TEST_ASSERT(strstr(allowedLocales, "ru") != NULL); /* Limit checks to USPOOF_CHAR_LIMIT. Some of the test data has whole script confusables also, * which we don't want to see in this test. */ uspoof_setChecks(sc, USPOOF_CHAR_LIMIT, &status); TEST_ASSERT_SUCCESS(status); checkResults = uspoof_check(sc, goodLatin, -1, NULL, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(0, checkResults); checkResults = uspoof_check(sc, goodGreek, -1, NULL, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(USPOOF_CHAR_LIMIT, checkResults); checkResults = uspoof_check(sc, goodCyrl, -1, NULL, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(0, checkResults); /* Reset with an empty locale list, which should allow all characters to pass */ uspoof_setAllowedLocales(sc, " ", &status); TEST_ASSERT_SUCCESS(status); checkResults = uspoof_check(sc, goodGreek, -1, NULL, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(0, checkResults); TEST_TEARDOWN; /* * AllowedChars set/get the USet of allowed characters. */ TEST_SETUP const USet *set; USet *tmpSet; int32_t checkResults; /* By default, we should see no restriction; the USet should allow all characters. */ set = uspoof_getAllowedChars(sc, &status); TEST_ASSERT_SUCCESS(status); tmpSet = uset_open(0, 0x10ffff); TEST_ASSERT(uset_equals(tmpSet, set)); /* Setting the allowed chars should enable the check. */ uspoof_setChecks(sc, USPOOF_ALL_CHECKS & ~USPOOF_CHAR_LIMIT, &status); TEST_ASSERT_SUCCESS(status); /* Remove a character that is in our good Latin test identifier from the allowed chars set. */ uset_remove(tmpSet, goodLatin[1]); uspoof_setAllowedChars(sc, tmpSet, &status); TEST_ASSERT_SUCCESS(status); uset_close(tmpSet); /* Latin Identifier should now fail; other non-latin test cases should still be OK */ checkResults = uspoof_check(sc, goodLatin, -1, NULL, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(USPOOF_CHAR_LIMIT, checkResults); checkResults = uspoof_check(sc, goodGreek, -1, NULL, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(USPOOF_WHOLE_SCRIPT_CONFUSABLE, checkResults); TEST_TEARDOWN; /* * check UTF-8 */ TEST_SETUP char utf8buf[200]; int32_t checkResults; int32_t position; u_strToUTF8(utf8buf, sizeof(utf8buf), NULL, goodLatin, -1, &status); TEST_ASSERT_SUCCESS(status); position = 666; checkResults = uspoof_checkUTF8(sc, utf8buf, -1, &position, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(0, checkResults); TEST_ASSERT_EQ(666, position); u_strToUTF8(utf8buf, sizeof(utf8buf), NULL, goodCyrl, -1, &status); TEST_ASSERT_SUCCESS(status); checkResults = uspoof_checkUTF8(sc, utf8buf, -1, &position, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(0, checkResults); u_strToUTF8(utf8buf, sizeof(utf8buf), NULL, scMixed, -1, &status); TEST_ASSERT_SUCCESS(status); position = 666; checkResults = uspoof_checkUTF8(sc, utf8buf, -1, &position, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(USPOOF_MIXED_SCRIPT_CONFUSABLE | USPOOF_SINGLE_SCRIPT , checkResults); TEST_ASSERT_EQ(2, position); TEST_TEARDOWN; /* * uspoof_areConfusable() */ TEST_SETUP int32_t checkResults; checkResults = uspoof_areConfusable(sc, scLatin, -1, scMixed, -1, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(USPOOF_MIXED_SCRIPT_CONFUSABLE, checkResults); checkResults = uspoof_areConfusable(sc, goodGreek, -1, scLatin, -1, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(0, checkResults); checkResults = uspoof_areConfusable(sc, lll_Latin_a, -1, lll_Latin_b, -1, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(USPOOF_SINGLE_SCRIPT_CONFUSABLE, checkResults); TEST_TEARDOWN; /* * areConfusableUTF8 */ TEST_SETUP int32_t checkResults; char s1[200]; char s2[200]; u_strToUTF8(s1, sizeof(s1), NULL, scLatin, -1, &status); u_strToUTF8(s2, sizeof(s2), NULL, scMixed, -1, &status); TEST_ASSERT_SUCCESS(status); checkResults = uspoof_areConfusableUTF8(sc, s1, -1, s2, -1, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(USPOOF_MIXED_SCRIPT_CONFUSABLE, checkResults); u_strToUTF8(s1, sizeof(s1), NULL, goodGreek, -1, &status); u_strToUTF8(s2, sizeof(s2), NULL, scLatin, -1, &status); TEST_ASSERT_SUCCESS(status); checkResults = uspoof_areConfusableUTF8(sc, s1, -1, s2, -1, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(0, checkResults); u_strToUTF8(s1, sizeof(s1), NULL, lll_Latin_a, -1, &status); u_strToUTF8(s2, sizeof(s2), NULL, lll_Latin_b, -1, &status); TEST_ASSERT_SUCCESS(status); checkResults = uspoof_areConfusableUTF8(sc, s1, -1, s2, -1, &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(USPOOF_SINGLE_SCRIPT_CONFUSABLE, checkResults); TEST_TEARDOWN; /* * getSkeleton */ TEST_SETUP UChar dest[100]; int32_t skelLength; skelLength = uspoof_getSkeleton(sc, USPOOF_ANY_CASE, lll_Latin_a, -1, dest, sizeof(dest)/sizeof(UChar), &status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT_EQ(0, u_strcmp(lll_Skel, dest)); TEST_ASSERT_EQ(u_strlen(lll_Skel), skelLength); skelLength = uspoof_getSkeletonUTF8(sc, USPOOF_ANY_CASE, goodLatinUTF8, -1, dest, sizeof(dest)/sizeof(UChar), &status); TEST_ASSERT_SUCCESS(status); skelLength = uspoof_getSkeleton(sc, USPOOF_ANY_CASE, lll_Latin_a, -1, NULL, 0, &status); TEST_ASSERT_EQ(U_BUFFER_OVERFLOW_ERROR, status); TEST_ASSERT_EQ(3, skelLength); status = U_ZERO_ERROR; TEST_TEARDOWN; }
void TestCzechMonths459() { int32_t lneed, pos; UChar *pattern=NULL, *tzID=NULL; UChar *juneStr, *julyStr; UDateFormat *fmt; UCalendar *cal; UDate june, july, d; UErrorCode status = U_ZERO_ERROR; UChar *date; ctest_setTimeZone(NULL, &status); fmt = udat_open(UDAT_FULL, UDAT_FULL, "cs", NULL, 0, NULL, 0, &status); if(U_FAILURE(status)){ log_data_err("Error in constructing the date format -> %s (Are you missing data?)\n", u_errorName(status)); ctest_resetTimeZone(); return; } lneed=0; lneed=udat_toPattern(fmt, TRUE, NULL, lneed, &status); if(status==U_BUFFER_OVERFLOW_ERROR){ status=U_ZERO_ERROR; pattern=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); udat_toPattern(fmt, TRUE, pattern, lneed+1, &status); } if(U_FAILURE(status)){ log_err("Error in extracting the pattern\n"); } tzID=(UChar*)malloc(sizeof(UChar) * 4); u_uastrcpy(tzID, "GMT"); cal=ucal_open(tzID, u_strlen(tzID), "cs", UCAL_GREGORIAN, &status); if(U_FAILURE(status)){ log_err("error in ucal_open caldef : %s\n", myErrorName(status)); } ucal_setDate(cal, 1997, UCAL_JUNE, 15, &status); june=ucal_getMillis(cal, &status); ucal_setDate(cal, 1997, UCAL_JULY, 15, &status); july=ucal_getMillis(cal, &status); juneStr = myDateFormat(fmt, june); julyStr = myDateFormat(fmt, july); pos=0; if(juneStr == NULL) { log_data_err("Can't load juneStr. Quitting.\n"); return; } d = udat_parse(fmt, juneStr, u_strlen(juneStr), &pos, &status); date = myDateFormat(fmt, d); if(U_SUCCESS(status)){ UChar* out1 = myDateFormat(fmt, june); UChar* out2 = myDateFormat(fmt, d); if(u_strcmp(out1, out2) !=0) log_err("Error in handling the czech month june\n"); else log_verbose("Pass: Date = %s (czech month June)\n", aescstrdup(date, -1)); }else{ log_err("udat_parse failed. Error. %s\n",u_errorName(status)); } pos=0; d = udat_parse(fmt, julyStr, u_strlen(julyStr), &pos, &status); date = myDateFormat(fmt, d); if(u_strcmp(myDateFormat(fmt, july), myDateFormat(fmt, d) ) !=0) log_err("Error in handling the czech month july\n"); else log_verbose("Pass: Date = %s (czech month July)\n", aescstrdup(date, -1)); ctest_resetTimeZone(); udat_close(fmt); ucal_close(cal); free(pattern); free(tzID); }
void RuleBasedNumberFormat::init(const UnicodeString& rules, LocalizationInfo* localizationInfos, UParseError& pErr, UErrorCode& status) { // TODO: implement UParseError uprv_memset(&pErr, 0, sizeof(UParseError)); // Note: this can leave ruleSets == NULL, so remaining code should check if (U_FAILURE(status)) { return; } this->localizations = localizationInfos == NULL ? NULL : localizationInfos->ref(); UnicodeString description(rules); if (!description.length()) { status = U_MEMORY_ALLOCATION_ERROR; return; } // start by stripping the trailing whitespace from all the rules // (this is all the whitespace follwing each semicolon in the // description). This allows us to look for rule-set boundaries // by searching for ";%" without having to worry about whitespace // between the ; and the % stripWhitespace(description); // check to see if there's a set of lenient-parse rules. If there // is, pull them out into our temporary holding place for them, // and delete them from the description before the real desciption- // parsing code sees them int32_t lp = description.indexOf(gLenientParse, -1, 0); if (lp != -1) { // we've got to make sure we're not in the middle of a rule // (where "%%lenient-parse" would actually get treated as // rule text) if (lp == 0 || description.charAt(lp - 1) == gSemiColon) { // locate the beginning and end of the actual collation // rules (there may be whitespace between the name and // the first token in the description) int lpEnd = description.indexOf(gSemiPercent, 2, lp); if (lpEnd == -1) { lpEnd = description.length() - 1; } int lpStart = lp + u_strlen(gLenientParse); while (PatternProps::isWhiteSpace(description.charAt(lpStart))) { ++lpStart; } // copy out the lenient-parse rules and delete them // from the description lenientParseRules = new UnicodeString(); /* test for NULL */ if (lenientParseRules == 0) { status = U_MEMORY_ALLOCATION_ERROR; return; } lenientParseRules->setTo(description, lpStart, lpEnd - lpStart); description.remove(lp, lpEnd + 1 - lp); } } // pre-flight parsing the description and count the number of // rule sets (";%" marks the end of one rule set and the beginning // of the next) int numRuleSets = 0; for (int32_t p = description.indexOf(gSemiPercent, 2, 0); p != -1; p = description.indexOf(gSemiPercent, 2, p)) { ++numRuleSets; ++p; } ++numRuleSets; // our rule list is an array of the appropriate size ruleSets = (NFRuleSet **)uprv_malloc((numRuleSets + 1) * sizeof(NFRuleSet *)); /* test for NULL */ if (ruleSets == 0) { status = U_MEMORY_ALLOCATION_ERROR; return; } for (int i = 0; i <= numRuleSets; ++i) { ruleSets[i] = NULL; } // divide up the descriptions into individual rule-set descriptions // and store them in a temporary array. At each step, we also // new up a rule set, but all this does is initialize its name // and remove it from its description. We can't actually parse // the rest of the descriptions and finish initializing everything // because we have to know the names and locations of all the rule // sets before we can actually set everything up if(!numRuleSets) { status = U_ILLEGAL_ARGUMENT_ERROR; return; } UnicodeString* ruleSetDescriptions = new UnicodeString[numRuleSets]; if (ruleSetDescriptions == 0) { status = U_MEMORY_ALLOCATION_ERROR; return; } { int curRuleSet = 0; int32_t start = 0; for (int32_t p = description.indexOf(gSemiPercent, 2, 0); p != -1; p = description.indexOf(gSemiPercent, 2, start)) { ruleSetDescriptions[curRuleSet].setTo(description, start, p + 1 - start); ruleSets[curRuleSet] = new NFRuleSet(ruleSetDescriptions, curRuleSet, status); if (ruleSets[curRuleSet] == 0) { status = U_MEMORY_ALLOCATION_ERROR; goto cleanup; } ++curRuleSet; start = p + 1; } ruleSetDescriptions[curRuleSet].setTo(description, start, description.length() - start); ruleSets[curRuleSet] = new NFRuleSet(ruleSetDescriptions, curRuleSet, status); if (ruleSets[curRuleSet] == 0) { status = U_MEMORY_ALLOCATION_ERROR; goto cleanup; } } // now we can take note of the formatter's default rule set, which // is the last public rule set in the description (it's the last // rather than the first so that a user can create a new formatter // from an existing formatter and change its default behavior just // by appending more rule sets to the end) // {dlf} Initialization of a fraction rule set requires the default rule // set to be known. For purposes of initialization, this is always the // last public rule set, no matter what the localization data says. initDefaultRuleSet(); // finally, we can go back through the temporary descriptions // list and finish seting up the substructure (and we throw // away the temporary descriptions as we go) { for (int i = 0; i < numRuleSets; i++) { ruleSets[i]->parseRules(ruleSetDescriptions[i], this, status); } } // Now that the rules are initialized, the 'real' default rule // set can be adjusted by the localization data. // The C code keeps the localization array as is, rather than building // a separate array of the public rule set names, so we have less work // to do here-- but we still need to check the names. if (localizationInfos) { // confirm the names, if any aren't in the rules, that's an error // it is ok if the rules contain public rule sets that are not in this list for (int32_t i = 0; i < localizationInfos->getNumberOfRuleSets(); ++i) { UnicodeString name(TRUE, localizationInfos->getRuleSetName(i), -1); NFRuleSet* rs = findRuleSet(name, status); if (rs == NULL) { break; // error } if (i == 0) { defaultRuleSet = rs; } } } else { defaultRuleSet = getDefaultRuleSet(); } cleanup: delete[] ruleSetDescriptions; }
static void TestPUtilAPI(void){ double n1=0.0, y1=0.0, expn1, expy1; double value1 = 0.021; char *str=0; UBool isTrue=FALSE; log_verbose("Testing the API uprv_modf()\n"); y1 = uprv_modf(value1, &n1); expn1=0; expy1=0.021; if(y1 != expy1 || n1 != expn1){ log_err("Error in uprv_modf. Expected IntegralValue=%f, Got=%f, \n Expected FractionalValue=%f, Got=%f\n", expn1, n1, expy1, y1); } if(getTestOption(VERBOSITY_OPTION)){ log_verbose("[float] x = %f n = %f y = %f\n", value1, n1, y1); } log_verbose("Testing the API uprv_fmod()\n"); expn1=uprv_fmod(30.50, 15.00); doAssert(expn1, 0.5, "uprv_fmod(30.50, 15.00) failed."); log_verbose("Testing the API uprv_ceil()\n"); expn1=uprv_ceil(value1); doAssert(expn1, 1, "uprv_ceil(0.021) failed."); log_verbose("Testing the API uprv_floor()\n"); expn1=uprv_floor(value1); doAssert(expn1, 0, "uprv_floor(0.021) failed."); log_verbose("Testing the API uprv_fabs()\n"); expn1=uprv_fabs((2.02-1.345)); doAssert(expn1, 0.675, "uprv_fabs(2.02-1.345) failed."); log_verbose("Testing the API uprv_fmax()\n"); doAssert(uprv_fmax(2.4, 1.2), 2.4, "uprv_fmax(2.4, 1.2) failed."); log_verbose("Testing the API uprv_fmax() with x value= NaN\n"); expn1=uprv_fmax(uprv_getNaN(), 1.2); doAssert(expn1, uprv_getNaN(), "uprv_fmax(uprv_getNaN(), 1.2) failed. when one parameter is NaN"); log_verbose("Testing the API uprv_fmin()\n"); doAssert(uprv_fmin(2.4, 1.2), 1.2, "uprv_fmin(2.4, 1.2) failed."); log_verbose("Testing the API uprv_fmin() with x value= NaN\n"); expn1=uprv_fmin(uprv_getNaN(), 1.2); doAssert(expn1, uprv_getNaN(), "uprv_fmin(uprv_getNaN(), 1.2) failed. when one parameter is NaN"); log_verbose("Testing the API uprv_max()\n"); doAssert(uprv_max(4, 2), 4, "uprv_max(4, 2) failed."); log_verbose("Testing the API uprv_min()\n"); doAssert(uprv_min(-4, 2), -4, "uprv_min(-4, 2) failed."); log_verbose("Testing the API uprv_trunc()\n"); doAssert(uprv_trunc(12.3456), 12, "uprv_trunc(12.3456) failed."); doAssert(uprv_trunc(12.234E2), 1223, "uprv_trunc(12.234E2) failed."); doAssert(uprv_trunc(uprv_getNaN()), uprv_getNaN(), "uprv_trunc(uprv_getNaN()) failed. with parameter=NaN"); doAssert(uprv_trunc(uprv_getInfinity()), uprv_getInfinity(), "uprv_trunc(uprv_getInfinity()) failed. with parameter=Infinity"); log_verbose("Testing the API uprv_pow10()\n"); doAssert(uprv_pow10(4), 10000, "uprv_pow10(4) failed."); log_verbose("Testing the API uprv_isNegativeInfinity()\n"); isTrue=uprv_isNegativeInfinity(uprv_getInfinity() * -1); if(isTrue != TRUE){ log_err("ERROR: uprv_isNegativeInfinity failed.\n"); } log_verbose("Testing the API uprv_isPositiveInfinity()\n"); isTrue=uprv_isPositiveInfinity(uprv_getInfinity()); if(isTrue != TRUE){ log_err("ERROR: uprv_isPositiveInfinity failed.\n"); } log_verbose("Testing the API uprv_isInfinite()\n"); isTrue=uprv_isInfinite(uprv_getInfinity()); if(isTrue != TRUE){ log_err("ERROR: uprv_isInfinite failed.\n"); } #if 0 log_verbose("Testing the API uprv_digitsAfterDecimal()....\n"); doAssert(uprv_digitsAfterDecimal(value1), 3, "uprv_digitsAfterDecimal() failed."); doAssert(uprv_digitsAfterDecimal(1.2345E2), 2, "uprv_digitsAfterDecimal(1.2345E2) failed."); doAssert(uprv_digitsAfterDecimal(1.2345E-2), 6, "uprv_digitsAfterDecimal(1.2345E-2) failed."); doAssert(uprv_digitsAfterDecimal(1.2345E2), 2, "uprv_digitsAfterDecimal(1.2345E2) failed."); doAssert(uprv_digitsAfterDecimal(-1.2345E-20), 24, "uprv_digitsAfterDecimal(1.2345E-20) failed."); doAssert(uprv_digitsAfterDecimal(1.2345E20), 0, "uprv_digitsAfterDecimal(1.2345E20) failed."); doAssert(uprv_digitsAfterDecimal(-0.021), 3, "uprv_digitsAfterDecimal(-0.021) failed."); doAssert(uprv_digitsAfterDecimal(23.0), 0, "uprv_digitsAfterDecimal(23.0) failed."); doAssert(uprv_digitsAfterDecimal(0.022223333321), 9, "uprv_digitsAfterDecimal(0.022223333321) failed."); #endif log_verbose("Testing the API u_errorName()...\n"); str=(char*)u_errorName((UErrorCode)0); if(strcmp(str, "U_ZERO_ERROR") != 0){ log_err("ERROR: u_getVersion() failed. Expected: U_ZERO_ERROR Got=%s\n", str); } log_verbose("Testing the API u_errorName()...\n"); str=(char*)u_errorName((UErrorCode)-127); if(strcmp(str, "U_USING_DEFAULT_WARNING") != 0){ log_err("ERROR: u_getVersion() failed. Expected: U_USING_DEFAULT_WARNING Got=%s\n", str); } log_verbose("Testing the API u_errorName().. with BOGUS ERRORCODE...\n"); str=(char*)u_errorName((UErrorCode)200); if(strcmp(str, "[BOGUS UErrorCode]") != 0){ log_err("ERROR: u_getVersion() failed. Expected: [BOGUS UErrorCode] Got=%s\n", str); } { const char* dataDirectory; int32_t dataDirectoryLen; UChar *udataDir=0; UChar temp[100]; char *charvalue=0; log_verbose("Testing chars to UChars\n"); /* This cannot really work on a japanese system. u_uastrcpy will have different results than */ /* u_charsToUChars when there is a backslash in the string! */ /*dataDirectory=u_getDataDirectory();*/ dataDirectory="directory1"; /*no backslashes*/ dataDirectoryLen=(int32_t)strlen(dataDirectory); udataDir=(UChar*)malloc(sizeof(UChar) * (dataDirectoryLen + 1)); u_charsToUChars(dataDirectory, udataDir, (dataDirectoryLen + 1)); u_uastrcpy(temp, dataDirectory); if(u_strcmp(temp, udataDir) != 0){ log_err("ERROR: u_charsToUChars failed. Expected %s, Got %s\n", austrdup(temp), austrdup(udataDir)); } log_verbose("Testing UChars to chars\n"); charvalue=(char*)malloc(sizeof(char) * (u_strlen(udataDir) + 1)); u_UCharsToChars(udataDir, charvalue, (u_strlen(udataDir)+1)); if(strcmp(charvalue, dataDirectory) != 0){ log_err("ERROR: u_UCharsToChars failed. Expected %s, Got %s\n", charvalue, dataDirectory); } free(charvalue); free(udataDir); } log_verbose("Testing uprv_timezone()....\n"); { int32_t tzoffset = uprv_timezone(); log_verbose("Value returned from uprv_timezone = %d\n", tzoffset); if (tzoffset != 28800) { log_verbose("***** WARNING: If testing in the PST timezone, t_timezone should return 28800! *****"); } if ((tzoffset % 1800 != 0)) { log_info("Note: t_timezone offset of %ld (for %s : %s) is not a multiple of 30min.", tzoffset, uprv_tzname(0), uprv_tzname(1)); } /*tzoffset=uprv_getUTCtime();*/ } }
static void _expect(const UTransliterator* trans, const char* cfrom, const char* cto) { /* u_uastrcpy has no capacity param for the buffer -- so just * make all buffers way too big */ enum { CAP = 256 }; UChar from[CAP]; UChar to[CAP]; UChar buf[CAP]; const UChar *ID; int32_t IDLength; const char *id; UErrorCode status = U_ZERO_ERROR; int32_t limit; UTransPosition pos; XReplaceable xrep; XReplaceable *xrepPtr = &xrep; UReplaceableCallbacks xrepVtable; u_uastrcpy(from, cfrom); u_uastrcpy(to, cto); ID = utrans_getUnicodeID(trans, &IDLength); id = aescstrdup(ID, IDLength); /* utrans_transUChars() */ u_strcpy(buf, from); limit = u_strlen(buf); utrans_transUChars(trans, buf, NULL, CAP, 0, &limit, &status); if (U_FAILURE(status)) { log_err("FAIL: utrans_transUChars() failed, error=%s\n", u_errorName(status)); return; } if (0 == u_strcmp(buf, to)) { log_verbose("Ok: utrans_transUChars(%s) x %s -> %s\n", id, cfrom, cto); } else { char actual[CAP]; u_austrcpy(actual, buf); log_err("FAIL: utrans_transUChars(%s) x %s -> %s, expected %s\n", id, cfrom, actual, cto); } /* utrans_transIncrementalUChars() */ u_strcpy(buf, from); pos.start = pos.contextStart = 0; pos.limit = pos.contextLimit = u_strlen(buf); utrans_transIncrementalUChars(trans, buf, NULL, CAP, &pos, &status); utrans_transUChars(trans, buf, NULL, CAP, pos.start, &pos.limit, &status); if (U_FAILURE(status)) { log_err("FAIL: utrans_transIncrementalUChars() failed, error=%s\n", u_errorName(status)); return; } if (0 == u_strcmp(buf, to)) { log_verbose("Ok: utrans_transIncrementalUChars(%s) x %s -> %s\n", id, cfrom, cto); } else { char actual[CAP]; u_austrcpy(actual, buf); log_err("FAIL: utrans_transIncrementalUChars(%s) x %s -> %s, expected %s\n", id, cfrom, actual, cto); } /* utrans_trans() */ InitXReplaceableCallbacks(&xrepVtable); InitXReplaceable(&xrep, cfrom); limit = u_strlen(from); utrans_trans(trans, (UReplaceable*)xrepPtr, &xrepVtable, 0, &limit, &status); if (U_FAILURE(status)) { log_err("FAIL: utrans_trans() failed, error=%s\n", u_errorName(status)); FreeXReplaceable(&xrep); return; } if (0 == u_strcmp(xrep.text, to)) { log_verbose("Ok: utrans_trans(%s) x %s -> %s\n", id, cfrom, cto); } else { char actual[CAP]; u_austrcpy(actual, xrep.text); log_err("FAIL: utrans_trans(%s) x %s -> %s, expected %s\n", id, cfrom, actual, cto); } FreeXReplaceable(&xrep); /* utrans_transIncremental() */ InitXReplaceable(&xrep, cfrom); pos.start = pos.contextStart = 0; pos.limit = pos.contextLimit = u_strlen(from); utrans_transIncremental(trans, (UReplaceable*)xrepPtr, &xrepVtable, &pos, &status); utrans_trans(trans, (UReplaceable*)xrepPtr, &xrepVtable, pos.start, &pos.limit, &status); if (U_FAILURE(status)) { log_err("FAIL: utrans_transIncremental() failed, error=%s\n", u_errorName(status)); FreeXReplaceable(&xrep); return; } if (0 == u_strcmp(xrep.text, to)) { log_verbose("Ok: utrans_transIncremental(%s) x %s -> %s\n", id, cfrom, cto); } else { char actual[CAP]; u_austrcpy(actual, xrep.text); log_err("FAIL: utrans_transIncremental(%s) x %s -> %s, expected %s\n", id, cfrom, actual, cto); } FreeXReplaceable(&xrep); }
NumberFormat* NumberFormat::makeInstance(const Locale& desiredLocale, EStyles style, UErrorCode& status) { if (U_FAILURE(status)) return NULL; if (style < 0 || style >= kStyleCount) { status = U_ILLEGAL_ARGUMENT_ERROR; return NULL; } #ifdef U_WINDOWS char buffer[8]; int32_t count = desiredLocale.getKeywordValue("compat", buffer, sizeof(buffer), status); // if the locale has "@compat=host", create a host-specific NumberFormat if (count > 0 && uprv_strcmp(buffer, "host") == 0) { Win32NumberFormat *f = NULL; UBool curr = TRUE; switch (style) { case kNumberStyle: curr = FALSE; // fall-through case kCurrencyStyle: case kIsoCurrencyStyle: // do not support plural formatting here case kPluralCurrencyStyle: f = new Win32NumberFormat(desiredLocale, curr, status); if (U_SUCCESS(status)) { return f; } delete f; break; default: break; } } #endif NumberFormat* f = NULL; DecimalFormatSymbols* symbolsToAdopt = NULL; UnicodeString pattern; UResourceBundle *resource = ures_open((char *)0, desiredLocale.getName(), &status); UResourceBundle *numberPatterns = ures_getByKey(resource, DecimalFormat::fgNumberPatterns, NULL, &status); NumberingSystem *ns = NULL; UBool deleteSymbols = TRUE; UHashtable * cache = NULL; int32_t hashKey; UBool getCache = FALSE; UBool deleteNS = FALSE; if (U_FAILURE(status)) { // We don't appear to have resource data available -- use the last-resort data status = U_USING_FALLBACK_WARNING; // When the data is unavailable, and locale isn't passed in, last resort data is used. symbolsToAdopt = new DecimalFormatSymbols(status); // Creates a DecimalFormat instance with the last resort number patterns. pattern.setTo(TRUE, gLastResortNumberPatterns[style], -1); } else { // If not all the styled patterns exists for the NumberFormat in this locale, // sets the status code to failure and returns nil. if (ures_getSize(numberPatterns) < (int32_t)(sizeof(gLastResortNumberPatterns)/sizeof(gLastResortNumberPatterns[0])) -2 ) { //minus 2: ISO and plural status = U_INVALID_FORMAT_ERROR; goto cleanup; } // Loads the decimal symbols of the desired locale. symbolsToAdopt = new DecimalFormatSymbols(desiredLocale, status); int32_t patLen = 0; /* for ISOCURRENCYSTYLE and PLURALCURRENCYSTYLE, * the pattern is the same as the pattern of CURRENCYSTYLE * but by replacing the single currency sign with * double currency sign or triple currency sign. */ int styleInNumberPattern = ((style == kIsoCurrencyStyle || style == kPluralCurrencyStyle) ? kCurrencyStyle : style); const UChar *patResStr = ures_getStringByIndex(numberPatterns, (int32_t)styleInNumberPattern, &patLen, &status); // Creates the specified decimal format style of the desired locale. pattern.setTo(TRUE, patResStr, patLen); } if (U_FAILURE(status) || symbolsToAdopt == NULL) { goto cleanup; } if(style==kCurrencyStyle || style == kIsoCurrencyStyle){ const UChar* currPattern = symbolsToAdopt->getCurrencyPattern(); if(currPattern!=NULL){ pattern.setTo(currPattern, u_strlen(currPattern)); } } // Use numbering system cache hashtable UMTX_CHECK(&nscacheMutex, (UBool)(cache != NumberingSystem_cache), getCache); if (getCache) { umtx_lock(&nscacheMutex); cache = NumberingSystem_cache; umtx_unlock(&nscacheMutex); } // Check cache we got, create if non-existant status = U_ZERO_ERROR; if (cache == NULL) { cache = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status); if (cache == NULL || U_FAILURE(status)) { // cache not created - out of memory cache = NULL; } else { // cache created uhash_setValueDeleter(cache, deleteNumberingSystem); // set final NumberingSystem_cache value UHashtable* h = NULL; UMTX_CHECK(&nscacheMutex, (UBool)(h != NumberingSystem_cache), getCache); if (getCache) { umtx_lock(&nscacheMutex); h = NumberingSystem_cache; umtx_unlock(&nscacheMutex); } if (h == NULL) { umtx_lock(&nscacheMutex); NumberingSystem_cache = h = cache; cache = NULL; ucln_i18n_registerCleanup(UCLN_I18N_NUMFMT, numfmt_cleanup); umtx_unlock(&nscacheMutex); } if(cache != NULL) { uhash_close(cache); } cache = h; } } // Get cached numbering system if (cache != NULL) { hashKey = desiredLocale.hashCode(); umtx_lock(&nscacheMutex); ns = (NumberingSystem *)uhash_iget(cache, hashKey); if (ns == NULL) { ns = NumberingSystem::createInstance(desiredLocale,status); uhash_iput(cache, hashKey, (void*)ns, &status); } umtx_unlock(&nscacheMutex); } else { ns = NumberingSystem::createInstance(desiredLocale,status); deleteNS = TRUE; } // check results of getting a numbering system if ((ns == NULL) || (U_FAILURE(status))) { goto cleanup; } if (ns->isAlgorithmic()) { UnicodeString nsDesc; UnicodeString nsRuleSetGroup; UnicodeString nsRuleSetName; Locale nsLoc; URBNFRuleSetTag desiredRulesType = URBNF_NUMBERING_SYSTEM; nsDesc.setTo(ns->getDescription()); int32_t firstSlash = nsDesc.indexOf(gSlash); int32_t lastSlash = nsDesc.lastIndexOf(gSlash); if ( lastSlash > firstSlash ) { char nsLocID[ULOC_FULLNAME_CAPACITY]; nsDesc.extract(0,firstSlash,nsLocID,ULOC_FULLNAME_CAPACITY,US_INV); nsRuleSetGroup.setTo(nsDesc,firstSlash+1,lastSlash-firstSlash-1); nsRuleSetName.setTo(nsDesc,lastSlash+1); nsLoc = Locale::createFromName(nsLocID); UnicodeString SpelloutRules = UNICODE_STRING_SIMPLE("SpelloutRules"); if ( nsRuleSetGroup.compare(SpelloutRules) == 0 ) { desiredRulesType = URBNF_SPELLOUT; } } else { nsLoc = desiredLocale; nsRuleSetName.setTo(nsDesc); } RuleBasedNumberFormat *r = new RuleBasedNumberFormat(desiredRulesType,nsLoc,status); if (U_FAILURE(status) || r == NULL) { goto cleanup; } r->setDefaultRuleSet(nsRuleSetName,status); f = (NumberFormat *) r; } else { // replace single currency sign in the pattern with double currency sign // if the style is kIsoCurrencyStyle if (style == kIsoCurrencyStyle) { pattern.findAndReplace(gSingleCurrencySign, gDoubleCurrencySign); } f = new DecimalFormat(pattern, symbolsToAdopt, style, status); if (U_FAILURE(status) || f == NULL) { goto cleanup; } deleteSymbols = FALSE; } f->setLocaleIDs(ures_getLocaleByType(numberPatterns, ULOC_VALID_LOCALE, &status), ures_getLocaleByType(numberPatterns, ULOC_ACTUAL_LOCALE, &status)); cleanup: ures_close(numberPatterns); ures_close(resource); if (deleteNS && ns) { delete ns; } if (U_FAILURE(status)) { /* If f exists, then it will delete the symbols */ if (f==NULL) { delete symbolsToAdopt; } else { delete f; } return NULL; } if (f == NULL || symbolsToAdopt == NULL) { status = U_MEMORY_ALLOCATION_ERROR; f = NULL; } if (deleteSymbols && symbolsToAdopt != NULL) { delete symbolsToAdopt; } return f; }
void Test4029195() { int32_t resultlength, resultlengthneeded; UChar *fmdt, *todayS, *rt; UChar *pat=NULL; UChar *temp; UDate today, d1; UDateFormat *df; int32_t parsepos; UErrorCode status = U_ZERO_ERROR; log_verbose("Testing date format and parse function in regression test\n"); today = ucal_getNow(); df = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,"en_US", NULL, 0, NULL, 0, &status); if(U_FAILURE(status)) { log_data_err("FAIL: error in creating the dateformat using default date and time style : %s (Are you missing data?)\n", myErrorName(status)); return; } resultlength=0; resultlengthneeded=udat_toPattern(df, TRUE, NULL, resultlength, &status); if(status==U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; resultlength=resultlengthneeded + 1; pat=(UChar*)malloc(sizeof(UChar) * resultlength); udat_toPattern(df, TRUE, pat, resultlength, &status); } log_verbose("pattern: %s\n", austrdup(pat)); fmdt = myFormatit(df, today); if(fmdt) { log_verbose("today: %s\n", austrdup(fmdt)); } else { log_data_err("ERROR: couldn't format, exitting test"); return; } temp=(UChar*)malloc(sizeof(UChar) * 10); u_uastrcpy(temp, "M yyyy dd"); udat_applyPattern(df, TRUE, temp, u_strlen(temp)); todayS =myFormatit(df, today); log_verbose("After teh pattern is applied\n today: %s\n", austrdup(todayS) ); parsepos=0; d1=udat_parse(df, todayS, u_strlen(todayS), &parsepos, &status); if(U_FAILURE(status)) { log_err("FAIL: Error in parsing using udat_parse(.....): %s\n", myErrorName(status)); } rt =myFormatit(df, d1); log_verbose("today: %s\n", austrdup(rt) ); log_verbose("round trip: %s\n", austrdup(rt) ); if(u_strcmp(rt, todayS)!=0) { log_err("Fail: Want %s Got %s\n", austrdup(todayS), austrdup(rt) ); } else log_verbose("Pass: parse and format working fine\n"); udat_close(df); free(temp); if(pat != NULL) { free(pat); } }
void TZGNCore::initialize(const Locale& locale, UErrorCode& status) { if (U_FAILURE(status)) { return; } // TimeZoneNames fTimeZoneNames = TimeZoneNames::createInstance(locale, status); if (U_FAILURE(status)) { return; } // Initialize format patterns UnicodeString rpat(TRUE, gDefRegionPattern, -1); UnicodeString fpat(TRUE, gDefFallbackPattern, -1); UErrorCode tmpsts = U_ZERO_ERROR; // OK with fallback warning.. UResourceBundle *zoneStrings = ures_open(U_ICUDATA_ZONE, locale.getName(), &tmpsts); zoneStrings = ures_getByKeyWithFallback(zoneStrings, gZoneStrings, zoneStrings, &tmpsts); if (U_SUCCESS(tmpsts)) { const UChar *regionPattern = ures_getStringByKeyWithFallback(zoneStrings, gRegionFormatTag, NULL, &tmpsts); if (U_SUCCESS(tmpsts) && u_strlen(regionPattern) > 0) { rpat.setTo(regionPattern, -1); } tmpsts = U_ZERO_ERROR; const UChar *fallbackPattern = ures_getStringByKeyWithFallback(zoneStrings, gFallbackFormatTag, NULL, &tmpsts); if (U_SUCCESS(tmpsts) && u_strlen(fallbackPattern) > 0) { fpat.setTo(fallbackPattern, -1); } } ures_close(zoneStrings); fRegionFormat = new MessageFormat(rpat, status); if (fRegionFormat == NULL) { status = U_MEMORY_ALLOCATION_ERROR; } fFallbackFormat = new MessageFormat(fpat, status); if (fFallbackFormat == NULL) { status = U_MEMORY_ALLOCATION_ERROR; } if (U_FAILURE(status)) { cleanup(); return; } // locale display names fLocaleDisplayNames = LocaleDisplayNames::createInstance(locale); // hash table for names - no key/value deleters fLocationNamesMap = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status); if (U_FAILURE(status)) { cleanup(); return; } fPartialLocationNamesMap = uhash_open(hashPartialLocationKey, comparePartialLocationKey, NULL, &status); if (U_FAILURE(status)) { cleanup(); return; } uhash_setKeyDeleter(fPartialLocationNamesMap, uprv_free); // no value deleter // target region const char* region = fLocale.getCountry(); int32_t regionLen = uprv_strlen(region); if (regionLen == 0) { char loc[ULOC_FULLNAME_CAPACITY]; uloc_addLikelySubtags(fLocale.getName(), loc, sizeof(loc), &status); regionLen = uloc_getCountry(loc, fTargetRegion, sizeof(fTargetRegion), &status); if (U_SUCCESS(status)) { fTargetRegion[regionLen] = 0; } else { cleanup(); return; } } else if (regionLen < (int32_t)sizeof(fTargetRegion)) { uprv_strcpy(fTargetRegion, region); } else { fTargetRegion[0] = 0; } // preload generic names for the default zone TimeZone *tz = TimeZone::createDefault(); const UChar *tzID = ZoneMeta::getCanonicalCLDRID(*tz); if (tzID != NULL) { loadStrings(UnicodeString(tzID)); } delete tz; }
/* Test u_formatMessage() with various test patterns() */ static void MessageFormatTest( void ) { UChar *str; UChar* result; int32_t resultLengthOut,resultlength,i, patternlength; UErrorCode status = U_ZERO_ERROR; UDate d1=1000000000.0; ctest_setTimeZone(NULL, &status); str=(UChar*)malloc(sizeof(UChar) * 7); u_uastrncpy(str, "MyDisk", 7); resultlength=1; result=(UChar*)malloc(sizeof(UChar) * 1); log_verbose("Testing u_formatMessage()\n"); InitStrings(); for (i = 0; i < cnt_testCases; i++) { status=U_ZERO_ERROR; patternlength=u_strlen(testCasePatterns[i]); resultLengthOut=u_formatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength, &status, 1, 3456.00, d1); if(status== U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; resultlength=resultLengthOut+1; result=(UChar*)realloc(result,sizeof(UChar) * resultlength); u_formatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength, &status, 1, 3456.00, d1); } if(U_FAILURE(status)){ log_data_err("ERROR: failure in message format on testcase %d: %s (Are you missing data?)\n", i, myErrorName(status) ); continue; } if(u_strcmp(result, testResultStrings[i])==0){ log_verbose("PASS: MessagFormat successful on testcase : %d\n", i); } else{ log_err("FAIL: Error in MessageFormat on testcase : %d\n GOT %s EXPECTED %s\n", i, austrdup(result), austrdup(testResultStrings[i]) ); } } free(result); result = NULL; free(str); { for (i = 0; i < cnt_testCases; i++) { UParseError parseError; status=U_ZERO_ERROR; patternlength=u_strlen(testCasePatterns[i]); resultlength=0; resultLengthOut=u_formatMessageWithError( "en_US",testCasePatterns[i], patternlength, result, resultlength, &parseError,&status, 1, 3456.00, d1); if(status== U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; resultlength=resultLengthOut+1; result=(UChar*)malloc(sizeof(UChar) * resultlength); u_formatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength, &status, 1, 3456.00, d1); } if(U_FAILURE(status)){ log_data_err("ERROR: failure in message format on testcase %d: %s (Are you missing data?)\n", i, myErrorName(status) ); continue; } if(u_strcmp(result, testResultStrings[i])==0){ log_verbose("PASS: MessagFormat successful on testcase : %d\n", i); } else{ log_err("FAIL: Error in MessageFormat on testcase : %d\n GOT %s EXPECTED %s\n", i, austrdup(result), austrdup(testResultStrings[i]) ); } free(result); result=NULL; } } { UErrorCode ec = U_ZERO_ERROR; int32_t patternLength = u_strlen(testCasePatterns[0]); UMessageFormat formatter = umsg_open(testCasePatterns[0],patternLength,"en_US",NULL,&ec); if(U_FAILURE(ec)){ log_data_err("umsg_open() failed for testCasePattens[%d]. -> %s (Are you missing data?)\n",i, u_errorName(ec)); return; } for(i = 0;i<cnt_testCases; i++){ UParseError parseError; int32_t resultLength =0,count=0; int32_t one=0; int32_t two=0; UDate d2=0; result=NULL; patternLength = u_strlen(testCasePatterns[i]); umsg_applyPattern(formatter,testCasePatterns[i],patternLength,&parseError,&ec); if(U_FAILURE(ec)){ log_err("umsg_applyPattern() failed for testCasePattens[%d].\n",i); return; } /* pre-flight */ resultLength = umsg_format(formatter,result,resultLength,&ec,1,3456.00,d1); if(ec==U_BUFFER_OVERFLOW_ERROR){ ec=U_ZERO_ERROR; result = (UChar*) malloc(U_SIZEOF_UCHAR*resultLength+2); resultLength = umsg_format(formatter,result,resultLength+2,&ec,1,3456.00,d1); if(U_FAILURE(ec)){ log_err("ERROR: failure in message format on testcase %d: %s\n", i, u_errorName(status) ); free(result); return; } if(u_strcmp(result, testResultStrings[i])==0){ log_verbose("PASS: MessagFormat successful on testcase : %d\n", i); } else{ log_err("FAIL: Error in MessageFormat on testcase : %d\n GOT %s EXPECTED %s\n", i, austrdup(result), austrdup(testResultStrings[i]) ); } #if (U_PLATFORM == U_PF_LINUX) /* add platforms here .. */ log_verbose("Skipping potentially crashing test for mismatched varargs.\n"); #else log_verbose("Note: the next is a platform dependent test. If it crashes, add an exclusion for your platform near %s:%d\n", __FILE__, __LINE__); if (returnsNullForType(1, (double)2.0)) { /* HP/UX and possibly other platforms don't properly check for this case. We pass in a UDate, but the function expects a UDate *. When va_arg is used, most compilers will return NULL, but HP-UX won't do that and will return 2 in this case. This is a platform dependent test. It crashes on some systems. If you get a crash here, see the definition of returnsNullForType. This relies upon "undefined" behavior, as indicated by C99 7.15.1.1 paragraph 2 */ umsg_parse(formatter,result,resultLength,&count,&ec,one,two,d2); if(ec!=U_ILLEGAL_ARGUMENT_ERROR){ log_err("FAIL: Did not get expected error for umsg_parse(). Expected: U_ILLEGAL_ARGUMENT_ERROR Got: %s \n",u_errorName(ec)); }else{ ec = U_ZERO_ERROR; } } else { log_verbose("Warning: Returning NULL for a mismatched va_arg type isn't supported on this platform.\n", i); } #endif umsg_parse(formatter,result,resultLength,&count,&ec,&one,&two,&d2); if(U_FAILURE(ec)){ log_err("umsg_parse could not parse the pattern. Error: %s.\n",u_errorName(ec)); } free(result); }else{ log_err("FAIL: Expected U_BUFFER_OVERFLOW error while preflighting got: %s for testCasePatterns[%d]",u_errorName(ec),i); } } umsg_close(formatter); } FreeStrings(); ctest_resetTimeZone(); }
int32_t umsg_autoQuoteApostrophe(const UChar* pattern, int32_t patternLength, UChar* dest, int32_t destCapacity, UErrorCode* ec) { int32_t state = STATE_INITIAL; int32_t braceCount = 0; int32_t len = 0; if (ec == NULL || U_FAILURE(*ec)) { return -1; } if (pattern == NULL || patternLength < -1 || (dest == NULL && destCapacity > 0)) { *ec = U_ILLEGAL_ARGUMENT_ERROR; return -1; } U_ASSERT(destCapacity >= 0); if (patternLength == -1) { patternLength = u_strlen(pattern); } for (int i = 0; i < patternLength; ++i) { UChar c = pattern[i]; switch (state) { case STATE_INITIAL: switch (c) { case SINGLE_QUOTE: state = STATE_SINGLE_QUOTE; break; case CURLY_BRACE_LEFT: state = STATE_MSG_ELEMENT; ++braceCount; break; } break; case STATE_SINGLE_QUOTE: switch (c) { case SINGLE_QUOTE: state = STATE_INITIAL; break; case CURLY_BRACE_LEFT: case CURLY_BRACE_RIGHT: state = STATE_IN_QUOTE; break; default: MAppend(SINGLE_QUOTE); state = STATE_INITIAL; break; } break; case STATE_IN_QUOTE: switch (c) { case SINGLE_QUOTE: state = STATE_INITIAL; break; } break; case STATE_MSG_ELEMENT: switch (c) { case CURLY_BRACE_LEFT: ++braceCount; break; case CURLY_BRACE_RIGHT: if (--braceCount == 0) { state = STATE_INITIAL; } break; } break; default: // Never happens. break; } U_ASSERT(len >= 0); MAppend(c); } // End of scan if (state == STATE_SINGLE_QUOTE || state == STATE_IN_QUOTE) { MAppend(SINGLE_QUOTE); } return u_terminateUChars(dest, destCapacity, len, ec); }
void CharIterTest::TestConstructionAndEqualityUChariter() { U_STRING_DECL(testText, "Now is the time for all good men to come to the aid of their country.", 69); U_STRING_DECL(testText2, "Don't bother using this string.", 31); U_STRING_INIT(testText, "Now is the time for all good men to come to the aid of their country.", 69); U_STRING_INIT(testText2, "Don't bother using this string.", 31); UnicodeString result, result4, result5; UCharCharacterIterator* test1 = new UCharCharacterIterator(testText, u_strlen(testText)); UCharCharacterIterator* test2 = new UCharCharacterIterator(testText, u_strlen(testText), 5); UCharCharacterIterator* test3 = new UCharCharacterIterator(testText, u_strlen(testText), 2, 20, 5); UCharCharacterIterator* test4 = new UCharCharacterIterator(testText2, u_strlen(testText2)); UCharCharacterIterator* test5 = (UCharCharacterIterator*)test1->clone(); UCharCharacterIterator* test6 = new UCharCharacterIterator(*test1); // j785: length=-1 will use u_strlen() UCharCharacterIterator* test7a = new UCharCharacterIterator(testText, -1); UCharCharacterIterator* test7b = new UCharCharacterIterator(testText, -1); UCharCharacterIterator* test7c = new UCharCharacterIterator(testText, -1, 2, 20, 5); // Bad parameters. UCharCharacterIterator* test8a = new UCharCharacterIterator(testText, -1, -1, 20, 5); UCharCharacterIterator* test8b = new UCharCharacterIterator(testText, -1, 2, 100, 5); UCharCharacterIterator* test8c = new UCharCharacterIterator(testText, -1, 2, 20, 100); if (test8a->startIndex() < 0) errln("Construction failed: startIndex is negative"); if (test8b->endIndex() != u_strlen(testText)) errln("Construction failed: endIndex is different from the text length"); if (test8c->getIndex() < test8c->startIndex() || test8c->endIndex() < test8c->getIndex()) errln("Construction failed: index is invalid"); if (*test1 == *test2 || *test1 == *test3 || *test1 == *test4 ) errln("Construction or operator== failed: Unequal objects compared equal"); if (*test1 != *test5 ) errln("clone() or equals() failed: Two clones tested unequal"); if (*test6 != *test1 ) errln("copy construction or equals() failed: Two copies tested unequal"); if (test1->hashCode() == test2->hashCode() || test1->hashCode() == test3->hashCode() || test1->hashCode() == test4->hashCode()) errln("hashCode() failed: different objects have same hash code"); if (test1->hashCode() != test5->hashCode()) errln("hashCode() failed: identical objects have different hash codes"); test7a->getText(result); test7b->getText(result4); test7c->getText(result5); if(result != UnicodeString(testText) || result4 != result || result5 != result) errln("error in construction"); test1->getText(result); test4->getText(result4); test5->getText(result5); if(result != result5 || result == result4) errln("getText() failed"); test5->setText(testText2, u_strlen(testText2)); test5->getText(result5); if(result == result5 || result4 != result5) errln("setText() or getText() failed"); test5->setText(testText, u_strlen(testText)); test5->getText(result5); if(result != result5 || result == result4) errln("setText() or getText() round-trip failed"); test1->setIndex(5); if (*test1 != *test2 || *test1 == *test5) errln("setIndex() failed"); test8b->setIndex32(5); if (test8b->getIndex()!=5) errln("setIndex32() failed"); *test1 = *test3; if (*test1 != *test3 || *test1 == *test5) errln("operator= failed"); delete test1; delete test2; delete test3; delete test4; delete test5; delete test6; delete test7a; delete test7b; delete test7c; delete test8a; delete test8b; delete test8c; }
U_CAPI void U_EXPORT2 umsg_vparse(const UMessageFormat *fmt, const UChar *source, int32_t sourceLength, int32_t *count, va_list ap, UErrorCode *status) { //check arguments if(status==NULL||U_FAILURE(*status)) { return; } if(fmt==NULL||source==NULL || sourceLength<-1 || count==NULL){ *status=U_ILLEGAL_ARGUMENT_ERROR; return; } if(sourceLength==-1){ sourceLength=u_strlen(source); } UnicodeString srcString(source,sourceLength); Formattable *args = ((const MessageFormat*)fmt)->parse(srcString,*count,*status); UDate *aDate; double *aDouble; UChar *aString; int32_t* aInt; int64_t* aInt64; UnicodeString temp; int len =0; // assign formattables to varargs for(int32_t i = 0; i < *count; i++) { switch(args[i].getType()) { case Formattable::kDate: aDate = va_arg(ap, UDate*); if(aDate){ *aDate = args[i].getDate(); }else{ *status=U_ILLEGAL_ARGUMENT_ERROR; } break; case Formattable::kDouble: aDouble = va_arg(ap, double*); if(aDouble){ *aDouble = args[i].getDouble(); }else{ *status=U_ILLEGAL_ARGUMENT_ERROR; } break; case Formattable::kLong: aInt = va_arg(ap, int32_t*); if(aInt){ *aInt = (int32_t) args[i].getLong(); }else{ *status=U_ILLEGAL_ARGUMENT_ERROR; } break; case Formattable::kInt64: aInt64 = va_arg(ap, int64_t*); if(aInt64){ *aInt64 = args[i].getInt64(); }else{ *status=U_ILLEGAL_ARGUMENT_ERROR; } break; case Formattable::kString: aString = va_arg(ap, UChar*); if(aString){ args[i].getString(temp); len = temp.length(); temp.extract(0,len,aString); aString[len]=0; }else{ *status= U_ILLEGAL_ARGUMENT_ERROR; } break; case Formattable::kObject: // This will never happen because MessageFormat doesn't // support kObject. When MessageFormat is changed to // understand MeasureFormats, modify this code to do the // right thing. [alan] U_ASSERT(FALSE); break; // better not happen! case Formattable::kArray: U_ASSERT(FALSE); break; } } // clean up delete [] args; }
/* * Class: calliope_AeseFormatter * Method: format * Signature: (Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;Lcalliope/json/JSONResponse;)I */ JNIEXPORT jint JNICALL Java_calliope_AeseFormatter_format (JNIEnv *env, jobject obj, jstring text, jobjectArray markup, jobjectArray css, jobject jsonHtml) { int res=0; jsize i,len; UChar *html; jboolean isTextCopy=0; jchar *t_data = (jchar*)load_string(env, text, &isTextCopy); int t_len = u_strlen( t_data ); if ( t_data != NULL && markup != NULL && css != NULL ) { jboolean isMarkupCopy; jni_report( "about to call master_create\n" ); master *hf = master_create( t_data, t_len ); if ( hf != NULL ) { jni_report( "about to get markup array length\n" ); len = (*env)->GetArrayLength(env, markup); for ( i=0;i<len;i++ ) { res = 1; jni_report( "about to get markup str\n" ); jstring markup_str = (jstring)(*env)->GetObjectArrayElement( env, markup, i ); jni_report( "about to load c string\n" ); const char *markup_data = load_string_c(env, markup_str, &isMarkupCopy); if ( markup_data != NULL ) { res = master_load_markup( hf, markup_data, (int)strlen(markup_data) ); unload_string_c( env, markup_str, markup_data,isMarkupCopy); } if ( !res ) break; } if ( res ) { len = (*env)->GetArrayLength(env, css); for ( i=0;i<len;i++ ) { jboolean isCssCopy; jstring css_str = (jstring)(*env)->GetObjectArrayElement( env, css, i); const char *css_data = load_string_c(env,css_str,&isCssCopy); if ( css_data != NULL ) { res = master_load_css( hf, css_data, (int)strlen(css_data) ); unload_string_c( env, css_str, css_data, isCssCopy ); if ( !res ) break; } } if ( res ) { //jni_report( "about to call master_convert\n" ); html = master_convert( hf ); //jni_report( "finished calling master_convert\n" ); if ( html != NULL ) { res = set_string_field( env, jsonHtml, "body", html ); if ( res == 0 ) jni_report("set string failed tried to write %d chars\n",u_strlen(html)); } } } master_dispose( hf ); } unload_string(env,text,t_data,isTextCopy); } #ifdef DEBUG_MEMORY memory_print(); #endif return res; }
static void SplashLayout() { unichar_t *start, *pt, *lastspace; extern const char *source_modtime_str; extern const char *source_version_str; uc_strcpy(msg, "When my father finished his book on Renaissance printing (The Craft of Printing and the Publication of Shakespeare's Works) he told me that I would have to write the chapter on computer typography. This is my attempt to do so."); GDrawSetFont(splashw,splash_font); linecnt = 0; lines[linecnt++] = msg-1; for ( start = msg; *start!='\0'; start = pt ) { lastspace = NULL; for ( pt=start; ; ++pt ) { if ( *pt==' ' || *pt=='\0' ) { if ( GDrawGetTextWidth(splashw,start,pt-start)<splashimage.u.image->width-10 ) lastspace = pt; else break; if ( *pt=='\0' ) break; } } if ( lastspace!=NULL ) pt = lastspace; lines[linecnt++] = pt; if ( *pt ) ++pt; } uc_strcpy(pt, " FontForge used to be named PfaEdit."); pt += u_strlen(pt); lines[linecnt++] = pt; uc_strcpy(pt," git hash: ");; pt += u_strlen(pt); lines[linecnt++] = pt; uc_strcat(pt, FONTFORGE_GIT_VERSION); pt += u_strlen(pt); lines[linecnt++] = pt; uc_strcpy(pt," Version: ");; uc_strcat(pt,FONTFORGE_MODTIME_STR); pt += u_strlen(pt); lines[linecnt++] = pt; uc_strcat(pt," ("); uc_strcat(pt,FONTFORGE_MODTIME_STR); uc_strcat(pt,"-ML"); #ifdef FREETYPE_HAS_DEBUGGER uc_strcat(pt,"-TtfDb"); #endif #ifdef _NO_PYTHON uc_strcat(pt,"-NoPython"); #endif #ifdef FONTFORGE_CONFIG_USE_DOUBLE uc_strcat(pt,"-D"); #endif uc_strcat(pt,")"); pt += u_strlen(pt); lines[linecnt++] = pt; uc_strcpy(pt," Lib Version: "); uc_strcat(pt,FONTFORGE_MODTIME_STR); lines[linecnt++] = pt+u_strlen(pt); lines[linecnt] = NULL; is = u_strchr(msg,'('); ie = u_strchr(msg,')'); }
/** * Test currency "object" (we use this name to match the other C++ * test name and the Jave name). Actually, test ISO currency code * support in the C API. */ static void TestCurrencyObject(void) { UNumberFormat *currencyFmt; UChar *str=NULL, *res=NULL; int32_t lneed, i; UFieldPosition pos; UErrorCode status = U_ZERO_ERROR; const char* locale[]={ "fr_FR", "fr_FR", }; const char* currency[]={ "", "JPY", }; const char* result[]={ "1\\u00A0234,56\\u00A0\\u20AC", "1\\u00A0235\\u00A0JPY", }; log_verbose("\nTesting the number format with different currency codes\n"); for(i=0; i < 2; i++) { char cStr[20]={0}; UChar isoCode[16]={0}; currencyFmt = unum_open(UNUM_CURRENCY, NULL,0,locale[i],NULL, &status); if(U_FAILURE(status)){ log_data_err("Error in the construction of number format with style currency: %s (Are you missing data?)\n", myErrorName(status)); } else { if (*currency[i]) { u_uastrcpy(isoCode, currency[i]); unum_setTextAttribute(currencyFmt, UNUM_CURRENCY_CODE, isoCode, u_strlen(isoCode), &status); if(U_FAILURE(status)) { log_err("FAIL: can't set currency code %s\n", myErrorName(status) ); } } unum_getTextAttribute(currencyFmt, UNUM_CURRENCY_CODE, isoCode, sizeof(isoCode), &status); if(U_FAILURE(status)) { log_err("FAIL: can't get currency code %s\n", myErrorName(status) ); } u_UCharsToChars(isoCode,cStr,u_strlen(isoCode)); log_verbose("ISO code %s\n", cStr); if (*currency[i] && uprv_strcmp(cStr, currency[i])) { log_err("FAIL: currency should be %s, but is %s\n", currency[i], cStr); } lneed=0; lneed= unum_formatDouble(currencyFmt, 1234.56, NULL, lneed, NULL, &status); if(status==U_BUFFER_OVERFLOW_ERROR){ status=U_ZERO_ERROR; str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); pos.field = 0; unum_formatDouble(currencyFmt, 1234.56, str, lneed+1, &pos, &status); } if(U_FAILURE(status)) { log_err("Error in formatting using unum_formatDouble(.....): %s\n", myErrorName(status) ); } else { res=(UChar*)malloc(sizeof(UChar) * (strlen(result[i])+1) ); u_unescape(result[i],res, (int32_t)(strlen(result[i])+1)); if (u_strcmp(str, res) != 0){ log_err("FAIL: Expected %s Got: %s for locale: %s\n", result[i],aescstrdup(str, -1),locale[i]); } } } unum_close(currencyFmt); free(str); free(res); } }
/*test u_formatMessage() with sample patterns */ static void TestSampleMessageFormat(void) { UChar *str; UChar *result; UChar pattern[100], expected[100]; int32_t resultLengthOut, resultlength; UDate d = 837039928046.0; UErrorCode status = U_ZERO_ERROR; ctest_setTimeZone(NULL, &status); str=(UChar*)malloc(sizeof(UChar) * 15); u_uastrcpy(str, "abc"); u_uastrcpy(pattern, "There are {0} files on {1,date}"); u_uastrcpy(expected, "There are abc files on Jul 10, 1996"); result=(UChar*)malloc(sizeof(UChar) * 1); log_verbose("\nTesting a sample for Message format test#1\n"); resultlength=1; resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, d); if(status==U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; resultlength=resultLengthOut+1; result=(UChar*)realloc(result, sizeof(UChar) * resultlength); u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, d); } if(U_FAILURE(status)){ log_data_err("Error: failure in message format on test#1: %s (Are you missing data?)\n", myErrorName(status)); } else if(u_strcmp(result, expected)==0) log_verbose("PASS: MessagFormat successful on test#1\n"); else{ log_err("FAIL: Error in MessageFormat on test#1 \n GOT: %s EXPECTED: %s\n", austrdup(result), austrdup(expected) ); } log_verbose("\nTesting message format with another pattern test#2\n"); u_uastrcpy(pattern, "The disk \"{0}\" contains {1,number,integer} file(s)"); u_uastrcpy(expected, "The disk \"MyDisk\" contains 23 file(s)"); u_uastrcpy(str, "MyDisk"); resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, 235); if(status==U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; resultlength=resultLengthOut+1; result=(UChar*)realloc(result, sizeof(UChar) * (resultlength+1)); u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, 23); } if(U_FAILURE(status)){ log_data_err("Error: failure in message format on test#2 : %s (Are you missing data?)\n", myErrorName(status)); } else if(u_strcmp(result, expected)==0) log_verbose("PASS: MessagFormat successful on test#2\n"); else{ log_err("FAIL: Error in MessageFormat on test#2\n GOT: %s EXPECTED: %s\n", austrdup(result), austrdup(expected) ); } log_verbose("\nTesting message format with another pattern test#3\n"); u_uastrcpy(pattern, "You made a {0} of {1,number,currency}"); u_uastrcpy(expected, "You made a deposit of $500.00"); u_uastrcpy(str, "deposit"); resultlength=0; resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, str, 500.00); if(status==U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; resultlength=resultLengthOut+1; result=(UChar*)realloc(result, sizeof(UChar) * resultlength); u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, 500.00); } if(U_FAILURE(status)){ log_data_err("Error: failure in message format on test#3 : %s (Are you missing data?)\n", myErrorName(status)); } else if(u_strcmp(result, expected)==0) log_verbose("PASS: MessagFormat successful on test#3\n"); else{ log_err("FAIL: Error in MessageFormat on test#3\n GOT: %s EXPECTED %s\n", austrdup(result), austrdup(expected) ); } free(result); free(str); ctest_resetTimeZone(); }
/** * Test the functioning of the secondary grouping value. */ static void TestSecondaryGrouping(void) { UErrorCode status = U_ZERO_ERROR; UNumberFormat *f = NULL, *g= NULL; UNumberFormat *us = unum_open(UNUM_DECIMAL,NULL,0, "en_US", NULL,&status); UFieldPosition pos; UChar resultBuffer[512]; int32_t l = 1876543210L; UBool ok = TRUE; UChar buffer[512]; int32_t i; UBool expectGroup = FALSE, isGroup = FALSE; u_uastrcpy(buffer, "#,##,###"); f = unum_open(UNUM_IGNORE,buffer, -1, "en_US",NULL, &status); if (U_FAILURE(status)) { log_data_err("Error DecimalFormat ct -> %s (Are you missing data?)\n", u_errorName(status)); return; } pos.field = 0; unum_format(f, (int32_t)123456789L, resultBuffer, 512 , &pos, &status); u_uastrcpy(buffer, "12,34,56,789"); if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status)) { log_err("Fail: Formatting \"#,##,###\" pattern with 123456789 got %s, expected %s\n", resultBuffer, "12,34,56,789"); } if (pos.beginIndex != 0 && pos.endIndex != 12) { log_err("Fail: Formatting \"#,##,###\" pattern pos = (%d, %d) expected pos = (0, 12)\n", pos.beginIndex, pos.endIndex); } memset(resultBuffer,0, sizeof(UChar)*512); unum_toPattern(f, FALSE, resultBuffer, 512, &status); u_uastrcpy(buffer, "#,##,###"); if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status)) { log_err("Fail: toPattern() got %s, expected %s\n", resultBuffer, "#,##,###"); } memset(resultBuffer,0, sizeof(UChar)*512); u_uastrcpy(buffer, "#,###"); unum_applyPattern(f, FALSE, buffer, -1,NULL,NULL); if (U_FAILURE(status)) { log_err("Fail: applyPattern call failed\n"); } unum_setAttribute(f, UNUM_SECONDARY_GROUPING_SIZE, 4); unum_format(f, (int32_t)123456789L, resultBuffer, 512 , &pos, &status); u_uastrcpy(buffer, "12,3456,789"); if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status)) { log_err("Fail: Formatting \"#,###\" pattern with 123456789 got %s, expected %s\n", resultBuffer, "12,3456,789"); } memset(resultBuffer,0, sizeof(UChar)*512); unum_toPattern(f, FALSE, resultBuffer, 512, &status); u_uastrcpy(buffer, "#,####,###"); if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status)) { log_err("Fail: toPattern() got %s, expected %s\n", resultBuffer, "#,####,###"); } memset(resultBuffer,0, sizeof(UChar)*512); g = unum_open(UNUM_DECIMAL, NULL,0,"hi_IN",NULL, &status); if (U_FAILURE(status)) { log_err("Fail: Cannot create UNumberFormat for \"hi_IN\" locale.\n"); } unum_format(g, l, resultBuffer, 512, &pos, &status); unum_close(g); /* expect "1,87,65,43,210", but with Hindi digits */ /* 01234567890123 */ if (u_strlen(resultBuffer) != 14) { ok = FALSE; } else { for (i=0; i<u_strlen(resultBuffer); ++i) { expectGroup = FALSE; switch (i) { case 1: case 4: case 7: case 10: expectGroup = TRUE; break; } /* Later -- fix this to get the actual grouping */ /* character from the resource bundle. */ isGroup = (UBool)(resultBuffer[i] == 0x002C); if (isGroup != expectGroup) { ok = FALSE; break; } } } if (!ok) { log_err("FAIL Expected %s x hi_IN -> \"1,87,65,43,210\" (with Hindi digits), got %s\n", "1876543210L", resultBuffer); } unum_close(f); unum_close(us); }
/* Test u_formatMessage() and u_parseMessage() , format and parse sequence and round trip */ static void TestSampleFormatAndParse(void) { UChar *result, *tzID, *str; UChar pattern[100]; UChar expected[100]; int32_t resultLengthOut, resultlength; UCalendar *cal; UDate d1,d; UDateFormat *def1; UErrorCode status = U_ZERO_ERROR; int32_t value = 0; UChar ret[30]; ctest_setTimeZone(NULL, &status); log_verbose("Testing format and parse\n"); str=(UChar*)malloc(sizeof(UChar) * 25); u_uastrcpy(str, "disturbance in force"); tzID=(UChar*)malloc(sizeof(UChar) * 4); u_uastrcpy(tzID, "PST"); cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status); if(U_FAILURE(status)){ log_data_err("error in ucal_open caldef : %s - (Are you missing data?)\n", myErrorName(status) ); } ucal_setDateTime(cal, 1999, UCAL_MARCH, 18, 0, 0, 0, &status); d1=ucal_getMillis(cal, &status); if(U_FAILURE(status)){ log_data_err("Error: failure in get millis: %s - (Are you missing data?)\n", myErrorName(status) ); } log_verbose("\nTesting with pattern test#4"); u_uastrcpy(pattern, "On {0, date, long}, there was a {1} on planet {2,number,integer}"); u_uastrcpy(expected, "On March 18, 1999, there was a disturbance in force on planet 7"); resultlength=1; result=(UChar*)malloc(sizeof(UChar) * resultlength); resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, d1, str, 7); if(status==U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; resultlength=resultLengthOut+1; result=(UChar*)realloc(result, sizeof(UChar) * resultlength); u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, d1, str, 7); } if(U_FAILURE(status)){ log_data_err("ERROR: failure in message format test#4: %s (Are you missing data?)\n", myErrorName(status)); } else if(u_strcmp(result, expected)==0) log_verbose("PASS: MessagFormat successful on test#4\n"); else{ log_err("FAIL: Error in MessageFormat on test#4\n GOT: %s EXPECTED: %s\n", austrdup(result), austrdup(expected) ); } /*try to parse this and check*/ log_verbose("\nTesting the parse Message test#5\n"); u_parseMessage("en_US", pattern, u_strlen(pattern), result, u_strlen(result), &status, &d, ret, &value); if(U_FAILURE(status)){ log_data_err("ERROR: error in parsing: test#5: %s (Are you missing data?)\n", myErrorName(status)); } else if(value!=7 && u_strcmp(str,ret)!=0) log_err("FAIL: Error in parseMessage on test#5 \n"); else log_verbose("PASS: parseMessage successful on test#5\n"); def1 = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,NULL, NULL, 0, NULL,0,&status); if(U_FAILURE(status)) { log_data_err("error in creating the dateformat using short date and time style: %s (Are you missing data?)\n", myErrorName(status)); }else{ if(u_strcmp(myDateFormat(def1, d), myDateFormat(def1, d1))==0) log_verbose("PASS: parseMessage successful test#5\n"); else{ log_err("FAIL: parseMessage didn't parse the date successfully\n GOT: %s EXPECTED %s\n", austrdup(myDateFormat(def1,d)), austrdup(myDateFormat(def1,d1)) ); } } udat_close(def1); ucal_close(cal); free(result); free(str); free(tzID); ctest_resetTimeZone(); }
void Test4056591() { int i; UCalendar *cal; UDateFormat *def; UDate start,exp,got; UChar s[10]; UChar *gotdate, *expdate; UChar pat[10]; UDate d[4]; UErrorCode status = U_ZERO_ERROR; const char* strings[] = { "091225", "091224", "611226", "991227" }; log_verbose("Testing s[get] 2 digit year start regressively\n"); cal=ucal_open(NULL, 0, "en_US", UCAL_GREGORIAN, &status); if(U_FAILURE(status)) { log_err("error in ucal_open caldef : %s\n", myErrorName(status)); } ucal_setDateTime(cal, 1809, UCAL_DECEMBER, 25, 17, 40, 30, &status); d[0]=ucal_getMillis(cal, &status); if(U_FAILURE(status)) { log_err("Error: failure in get millis: %s\n", myErrorName(status)); } ucal_setDateTime(cal, 1909, UCAL_DECEMBER, 24, 17, 40, 30, &status); d[1]=ucal_getMillis(cal, &status); ucal_setDateTime(cal, 1861, UCAL_DECEMBER, 26, 17, 40, 30, &status); d[2]=ucal_getMillis(cal, &status); ucal_setDateTime(cal, 1999, UCAL_DECEMBER, 27, 17, 40, 30, &status); d[3]=ucal_getMillis(cal, &status); u_uastrcpy(pat, "yyMMdd"); def = udat_open(UDAT_IGNORE,UDAT_IGNORE,NULL, NULL, 0, pat, u_strlen(pat), &status); if(U_FAILURE(status)) { log_err_status(status, "FAIL: error in creating the dateformat using u_openPattern(): %s\n", myErrorName(status)); return; } start = 1800; udat_set2DigitYearStart(def, start, &status); if(U_FAILURE(status)) log_err("ERROR: in setTwoDigitStartDate: %s\n", myErrorName(status)); if( (udat_get2DigitYearStart(def, &status) != start)) log_err("ERROR: get2DigitYearStart broken\n"); for(i = 0; i < 4; ++i) { u_uastrcpy(s, strings[i]); exp = d[i]; got = udat_parse(def, s, u_strlen(s), 0, &status); gotdate=myFormatit(def, got); expdate=myFormatit(def, exp); if (gotdate == NULL || expdate == NULL) { log_err("myFormatit failed!\n"); } else if(u_strcmp(gotdate, expdate) !=0) { log_err("set2DigitYearStart broken for %s \n got: %s, expected: %s\n", austrdup(s), austrdup(gotdate), austrdup(expdate) ); } } udat_close(def); ucal_close(cal); }
/* Test message format with a Select option */ static void TestMsgFormatSelect(void) { UChar* str; UChar* str1; UErrorCode status = U_ZERO_ERROR; UChar *result; UChar pattern[100]; UChar expected[100]; int32_t resultlength,resultLengthOut; str=(UChar*)malloc(sizeof(UChar) * 25); u_uastrcpy(str, "Kirti"); str1=(UChar*)malloc(sizeof(UChar) * 25); u_uastrcpy(str1, "female"); log_verbose("Testing message format with Select test #1\n:"); u_uastrcpy(pattern, "{0} est {1, select, female {all\\u00E9e} other {all\\u00E9}} \\u00E0 Paris."); u_uastrcpy(expected, "Kirti est all\\u00E9e \\u00E0 Paris."); resultlength=0; resultLengthOut=u_formatMessage( "fr", pattern, u_strlen(pattern), NULL, resultlength, &status, str , str1); if(status==U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; resultlength=resultLengthOut+1; result=(UChar*)malloc(sizeof(UChar) * resultlength); u_formatMessage( "fr", pattern, u_strlen(pattern), result, resultlength, &status, str , str1); if(u_strcmp(result, expected)==0) log_verbose("PASS: MessagFormat successful on Select test#1\n"); else{ log_err("FAIL: Error in MessageFormat on Select test#1\n GOT %s EXPECTED %s\n", austrdup(result), austrdup(expected) ); } free(result); } if(U_FAILURE(status)){ log_data_err("ERROR: failure in message format on Select test#1 : %s \n", myErrorName(status)); } free(str); free(str1); /*Test a nested pattern*/ str=(UChar*)malloc(sizeof(UChar) * 25); u_uastrcpy(str, "Noname"); str1=(UChar*)malloc(sizeof(UChar) * 25); u_uastrcpy(str1, "other"); log_verbose("Testing message format with Select test #2\n:"); u_uastrcpy(pattern, "{0} est {1, select, female {{2,number,integer} all\\u00E9e} other {all\\u00E9}} \\u00E0 Paris."); u_uastrcpy(expected, "Noname est all\\u00E9 \\u00E0 Paris."); resultlength=0; resultLengthOut=u_formatMessage( "fr", pattern, u_strlen(pattern), NULL, resultlength, &status, str , str1,6); if(status==U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; resultlength=resultLengthOut+1; result=(UChar*)malloc(sizeof(UChar) * resultlength); u_formatMessage( "fr", pattern, u_strlen(pattern), result, resultlength, &status, str , str1); if(u_strcmp(result, expected)==0) log_verbose("PASS: MessagFormat successful on Select test#2\n"); else{ log_err("FAIL: Error in MessageFormat on Select test#2\n GOT %s EXPECTED %s\n", austrdup(result), austrdup(expected) ); } free(result); } if(U_FAILURE(status)){ log_data_err("ERROR: failure in message format on Select test#2 : %s \n", myErrorName(status)); } free(str); free(str1); }
void Test4073003() { int32_t pos,i; UDate d,dd; UChar *datestr; UChar temp[15]; UErrorCode status = U_ZERO_ERROR; UDateFormat *fmt; UChar *result, *result2; const char* tests [] = { "12/25/61", "12/25/1961", "4/3/1999", "4/3/99" }; fmt= udat_open(UDAT_SHORT,UDAT_SHORT ,NULL, NULL, 0, NULL, 0, &status); if(U_FAILURE(status)) { log_data_err("FAIL: error in creating the dateformat using short date and time style: %s (Are you missing data?)\n", myErrorName(status)); return; } u_uastrcpy(temp, "m/D/yy"); udat_applyPattern(fmt, FALSE, temp, u_strlen(temp)); for(i= 0; i < 4; i+=2) { status=U_ZERO_ERROR; datestr=(UChar*)malloc(sizeof(UChar) * (strlen(tests[i])+1)); u_uastrcpy(datestr, tests[i]); pos=0; d = udat_parse(fmt, datestr, u_strlen(datestr), &pos, &status); if(U_FAILURE(status)) { log_err("ERROR : in test 4073003: %s\n", myErrorName(status)); } free(datestr); datestr=(UChar*)malloc(sizeof(UChar) * (strlen(tests[i+1])+1)); u_uastrcpy(datestr, tests[i+1]); pos=0; status=U_ZERO_ERROR; dd = udat_parse(fmt, datestr, u_strlen(datestr), &pos, &status); if(U_FAILURE(status)) { log_err("ERROR : in test 4073003: %s\n", myErrorName(status)); } free(datestr); result =myFormatit(fmt, d); result2 =myFormatit(fmt, dd); if(!result || !result2) { log_data_err("Fail: could not format - exitting test\n"); return; } if (u_strcmp(result, result2)!=0) { log_err("Fail: %s != %s\n", austrdup(result), austrdup(result2) ); } else { log_verbose("Ok: %s == %s\n", austrdup(result), austrdup(result2) ); } } udat_close(fmt); }
/* test message format with a choice option */ static void TestMsgFormatChoice(void) { UChar* str; UErrorCode status = U_ZERO_ERROR; UChar *result; UChar pattern[100]; UChar expected[100]; int32_t resultlength,resultLengthOut; str=(UChar*)malloc(sizeof(UChar) * 25); u_uastrcpy(str, "MyDisk"); log_verbose("Testing message format with choice test #6\n:"); /* * Before ICU 4.8, umsg_xxx() did not detect conflicting argument types, * and this pattern had {0,number,integer} as the inner argument. * The choice argument has kDouble type while {0,number,integer} has kLong (int32_t). * ICU 4.8 and above detects this as an error. * We changed this pattern to work as intended. */ u_uastrcpy(pattern, "The disk {1} contains {0,choice,0#no files|1#one file|1<{0,number} files}"); u_uastrcpy(expected, "The disk MyDisk contains 100 files"); resultlength=0; resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, 100., str); if(status==U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; resultlength=resultLengthOut+1; result=(UChar*)malloc(sizeof(UChar) * resultlength); u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, 100., str); if(u_strcmp(result, expected)==0) log_verbose("PASS: MessagFormat successful on test#6\n"); else{ log_err("FAIL: Error in MessageFormat on test#6\n GOT %s EXPECTED %s\n", austrdup(result), austrdup(expected) ); } free(result); } if(U_FAILURE(status)){ log_data_err("ERROR: failure in message format on test#6 : %s (Are you missing data?)\n", myErrorName(status)); } log_verbose("Testing message format with choice test #7\n:"); u_uastrcpy(expected, "The disk MyDisk contains no files"); resultlength=0; resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, 0., str); if(status==U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; resultlength=resultLengthOut+1; result=(UChar*)malloc(sizeof(UChar) * resultlength); u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, 0., str); if(u_strcmp(result, expected)==0) log_verbose("PASS: MessagFormat successful on test#7\n"); else{ log_err("FAIL: Error in MessageFormat on test#7\n GOT: %s EXPECTED %s\n", austrdup(result), austrdup(expected) ); } free(result); } if(U_FAILURE(status)){ log_data_err("ERROR: failure in message format on test#7 : %s (Are you missing data?)\n", myErrorName(status)); } log_verbose("Testing message format with choice test #8\n:"); u_uastrcpy(expected, "The disk MyDisk contains one file"); resultlength=0; resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, 1., str); if(status==U_BUFFER_OVERFLOW_ERROR) { status=U_ZERO_ERROR; resultlength=resultLengthOut+1; result=(UChar*)malloc(sizeof(UChar) * resultlength); u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, 1., str); if(u_strcmp(result, expected)==0) log_verbose("PASS: MessagFormat successful on test#8\n"); else{ log_err("FAIL: Error in MessageFormat on test#8\n GOT %s EXPECTED: %s\n", austrdup(result), austrdup(expected) ); } free(result); } if(U_FAILURE(status)){ log_data_err("ERROR: failure in message format on test#8 : %s (Are you missing data?)\n", myErrorName(status)); } free(str); }
U_CAPI int32_t U_EXPORT2 uhash_hashUChars(const UHashTok key) { const UChar *s = (const UChar *)key.pointer; return s == NULL ? 0 : ustr_hashUCharsN(s, u_strlen(s)); }
/* Test the handling of quotes*/ static void TestQuotes(void) { int32_t lneed; UErrorCode status=U_ZERO_ERROR; UChar pat[15]; UChar res[15]; UChar *str=NULL; UNumberFormat *fmt; char tempBuf[256]; log_verbose("\nTestting the handling of quotes in number format\n"); u_uastrcpy(pat, "a'fo''o'b#"); fmt =unum_open(UNUM_IGNORE,pat, u_strlen(pat), "en_US",NULL, &status); if(U_FAILURE(status)){ log_err_status(status, "Error in number format costruction using pattern \"a'fo''o'b#\" -> %s\n", u_errorName(status)); } lneed=0; lneed=unum_format(fmt, 123, NULL, lneed, NULL, &status); if(status==U_BUFFER_OVERFLOW_ERROR){ status=U_ZERO_ERROR; str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); unum_format(fmt, 123, str, lneed+1, NULL, &status); } if(U_FAILURE(status) || !str) { log_err_status(status, "Error in formatting using unum_format(.....): %s\n", myErrorName(status) ); return; } log_verbose("Pattern \"%s\" \n", u_austrcpy(tempBuf, pat) ); log_verbose("Format 123 -> %s\n", u_austrcpy(tempBuf, str) ); u_uastrcpy(res, "afo'ob123"); if(u_strcmp(str, res) != 0) log_err("FAIL: Expected afo'ob123"); free(str); unum_close(fmt); u_uastrcpy(pat, ""); u_uastrcpy(pat, "a''b#"); fmt =unum_open(UNUM_IGNORE,pat, u_strlen(pat), "en_US",NULL, &status); if(U_FAILURE(status)){ log_err("Error in number format costruction using pattern \"a''b#\"\n"); } lneed=0; lneed=unum_format(fmt, 123, NULL, lneed, NULL, &status); if(status==U_BUFFER_OVERFLOW_ERROR){ status=U_ZERO_ERROR; str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); unum_format(fmt, 123, str, lneed+1, NULL, &status); } if(U_FAILURE(status)) { log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) ); } log_verbose("Pattern \"%s\" \n", u_austrcpy(tempBuf, pat) ); log_verbose("Format 123 -> %s\n", u_austrcpy(tempBuf, str) ); u_uastrcpy(res, ""); u_uastrcpy(res, "a'b123"); if(u_strcmp(str, res) != 0) log_err("FAIL: Expected a'b123\n"); free(str); unum_close(fmt); }
/* UReplaceableCallbacks callback */ static int32_t Xlength(const UReplaceable* rep) { const XReplaceable* x = (const XReplaceable*)rep; return u_strlen(x->text); }
/* Test exponential pattern*/ static void TestExponential(void) { int32_t pat_length, val_length, lval_length; int32_t ival, ilval, p, v, lneed; UNumberFormat *fmt; int32_t ppos; UChar *upat; UChar pattern[20]; UChar *str=NULL; UChar uvalfor[20], ulvalfor[20]; char tempMsgBug[256]; double a; UErrorCode status = U_ZERO_ERROR; #if U_PLATFORM == U_PF_OS390 static const double val[] = { 0.01234, 123456789, 1.23e75, -3.141592653e-78 }; #else static const double val[] = { 0.01234, 123456789, 1.23e300, -3.141592653e-271 }; #endif static const char* pat[] = { "0.####E0", "00.000E00", "##0.######E000", "0.###E0;[0.###E0]" }; static const int32_t lval[] = { 0, -1, 1, 123456789 }; static const char* valFormat[] = { "1.234E-2", "1.2346E8", "1.23E300", "-3.1416E-271", "12.340E-03", "12.346E07", "12.300E299", "-31.416E-272", "12.34E-003", "123.4568E006", "1.23E300", "-314.1593E-273", "1.234E-2", "1.235E8", "1.23E300", "[3.142E-271]" }; static const char* lvalFormat[] = { "0E0", "-1E0", "1E0", "1.2346E8", "00.000E00", "-10.000E-01", "10.000E-01", "12.346E07", "0E000", "-1E000", "1E000", "123.4568E006", "0E0", "[1E0]", "1E0", "1.235E8" }; static const double valParse[] = { #if U_PLATFORM == U_PF_OS390 0.01234, 123460000, 1.23E75, -3.1416E-78, 0.01234, 123460000, 1.23E75, -3.1416E-78, 0.01234, 123456800, 1.23E75, -3.141593E-78, 0.01234, 123500000, 1.23E75, -3.142E-78 #else /* We define the whole IEEE 754 number in the 4th column because Visual Age 7 has a bug in rounding numbers. */ 0.01234, 123460000, 1.23E300, -3.1415999999999999E-271, 0.01234, 123460000, 1.23E300, -3.1415999999999999E-271, 0.01234, 123456800, 1.23E300, -3.1415929999999999E-271, 0.01234, 123500000, 1.23E300, -3.1420000000000001E-271 #endif }; static const int32_t lvalParse[] = { 0, -1, 1, 123460000, 0, -1, 1, 123460000, 0, -1, 1, 123456800, 0, -1, 1, 123500000 }; pat_length = UPRV_LENGTHOF(pat); val_length = UPRV_LENGTHOF(val); lval_length = UPRV_LENGTHOF(lval); ival = 0; ilval = 0; for (p=0; p < pat_length; ++p) { upat=(UChar*)malloc(sizeof(UChar) * (strlen(pat[p])+1) ); u_uastrcpy(upat, pat[p]); fmt=unum_open(UNUM_IGNORE,upat, u_strlen(upat), "en_US",NULL, &status); if (U_FAILURE(status)) { log_err_status(status, "FAIL: Bad status returned by Number format construction with pattern %s -> %s\n", pat[p], u_errorName(status)); continue; } lneed= u_strlen(upat) + 1; unum_toPattern(fmt, FALSE, pattern, lneed, &status); log_verbose("Pattern \" %s \" -toPattern-> \" %s \" \n", upat, u_austrcpy(tempMsgBug, pattern) ); for (v=0; v<val_length; ++v) { /*format*/ lneed=0; lneed=unum_formatDouble(fmt, val[v], NULL, lneed, NULL, &status); if(status==U_BUFFER_OVERFLOW_ERROR){ status=U_ZERO_ERROR; str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); unum_formatDouble(fmt, val[v], str, lneed+1, NULL, &status); } if(U_FAILURE(status)) { log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) ); } u_uastrcpy(uvalfor, valFormat[v+ival]); if(u_strcmp(str, uvalfor) != 0) log_verbose("FAIL: Expected %s ( %s )\n", valFormat[v+ival], u_austrcpy(tempMsgBug, uvalfor) ); /*parsing*/ ppos=0; a=unum_parseDouble(fmt, str, u_strlen(str), &ppos, &status); if (ppos== u_strlen(str)) { if (a != valParse[v+ival]) log_err("FAIL: Expected: %e, Got: %g\n", valParse[v+ival], a); } else log_err(" FAIL: Partial parse ( %d chars ) -> %e\n", ppos, a); free(str); } for (v=0; v<lval_length; ++v) { /*format*/ lneed=0; lneed=unum_formatDouble(fmt, lval[v], NULL, lneed, NULL, &status); if(status==U_BUFFER_OVERFLOW_ERROR){ status=U_ZERO_ERROR; str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); unum_formatDouble(fmt, lval[v], str, lneed+1, NULL, &status); } if(U_FAILURE(status)) { log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) ); } /*printf(" Format %e -> %s\n", lval[v], austrdup(str) );*/ u_uastrcpy(ulvalfor, lvalFormat[v+ilval]); if(u_strcmp(str, ulvalfor) != 0) log_err("FAIL: Expected %s ( %s )\n", valFormat[v+ilval], austrdup(ulvalfor) ); /*parsing*/ ppos=0; a=unum_parseDouble(fmt, str, u_strlen(str), &ppos, &status); if (ppos== u_strlen(str)) { /*printf(" Parse -> %e\n", a);*/ if (a != lvalParse[v+ilval]) log_err("FAIL: Expected : %e\n", valParse[v+ival]); } else log_err(" FAIL: Partial parse ( %d chars ) -> %e\n", ppos, a); free(str); } ival += val_length; ilval += lval_length; unum_close(fmt); free(upat); } }
UCharCharacterIterator::UCharCharacterIterator(const UChar* textPtr, int32_t length) : CharacterIterator(textPtr != 0 ? (length>=0 ? length : u_strlen(textPtr)) : 0), text(textPtr) { }
/** * Test the handling of the currency symbol in patterns. */ static void TestCurrencySign(void) { int32_t lneed; UNumberFormat *fmt; UChar *pattern=NULL; UChar *str=NULL; UChar *pat=NULL; UChar *res=NULL; UErrorCode status = U_ZERO_ERROR; char tempBuf[256]; pattern=(UChar*)malloc(sizeof(UChar) * (strlen("*#,##0.00;-*#,##0.00") + 1) ); u_uastrcpy(pattern, "*#,##0.00;-*#,##0.00"); pattern[0]=pattern[11]=0xa4; /* insert latin-1 currency symbol */ fmt = unum_open(UNUM_IGNORE,pattern, u_strlen(pattern), "en_US",NULL, &status); if(U_FAILURE(status)){ log_err_status(status, "Error in number format construction with pattern \"\\xA4#,##0.00;-\\xA4#,##0.00\\\" -> %s\n", u_errorName(status)); } lneed=0; lneed=unum_formatDouble(fmt, 1234.56, NULL, lneed, NULL, &status); if(status==U_BUFFER_OVERFLOW_ERROR){ status=U_ZERO_ERROR; str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); unum_formatDouble(fmt, 1234.56, str, lneed+1, NULL, &status); } if(U_FAILURE(status)) { log_err_status(status, "Error in formatting using unum_format(.....): %s\n", myErrorName(status) ); } lneed=0; lneed=unum_toPattern(fmt, FALSE, NULL, lneed, &status); if(status==U_BUFFER_OVERFLOW_ERROR){ status=U_ZERO_ERROR; pat=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); unum_formatDouble(fmt, FALSE, pat, lneed+1, NULL, &status); } log_verbose("Pattern \" %s \" \n", u_austrcpy(tempBuf, pat)); log_verbose("Format 1234.56 -> %s\n", u_austrcpy(tempBuf, str) ); if(U_SUCCESS(status) && str) { res=(UChar*)malloc(sizeof(UChar) * (strlen("$1,234.56")+1) ); u_uastrcpy(res, "$1,234.56"); if (u_strcmp(str, res) !=0) log_data_err("FAIL: Expected $1,234.56\n"); } else { log_err_status(status, "Error formatting -> %s\n", u_errorName(status)); } free(str); free(res); free(pat); lneed=0; lneed=unum_formatDouble(fmt, -1234.56, NULL, lneed, NULL, &status); if(status==U_BUFFER_OVERFLOW_ERROR){ status=U_ZERO_ERROR; str=(UChar*)malloc(sizeof(UChar) * (lneed+1) ); unum_formatDouble(fmt, -1234.56, str, lneed+1, NULL, &status); } if(U_FAILURE(status)) { log_err_status(status, "Error in formatting using unum_format(.....): %s\n", myErrorName(status) ); } if(str) { res=(UChar*)malloc(sizeof(UChar) * (strlen("-$1,234.56")+1) ); u_uastrcpy(res, "-$1,234.56"); if (u_strcmp(str, res) != 0) log_data_err("FAIL: Expected -$1,234.56\n"); free(str); free(res); } unum_close(fmt); free(pattern); }
void RBBIAPITest::TestRefreshInputText() { /* * RefreshInput changes out the input of a Break Iterator without * changing anything else in the iterator's state. Used with Java JNI, * when Java moves the underlying string storage. This test * runs BreakIterator::next() repeatedly, moving the text in the middle of the sequence. * The right set of boundaries should still be found. */ UChar testStr[] = {0x20, 0x41, 0x20, 0x42, 0x20, 0x43, 0x20, 0x44, 0x0}; /* = " A B C D" */ UChar movedStr[] = {0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0}; UErrorCode status = U_ZERO_ERROR; UText ut1 = UTEXT_INITIALIZER; UText ut2 = UTEXT_INITIALIZER; RuleBasedBreakIterator *bi = (RuleBasedBreakIterator *)BreakIterator::createLineInstance(Locale::getEnglish(), status); TEST_ASSERT_SUCCESS(status); utext_openUChars(&ut1, testStr, -1, &status); TEST_ASSERT_SUCCESS(status); bi->setText(&ut1, status); TEST_ASSERT_SUCCESS(status); /* Line boundaries will occur before each letter in the original string */ TEST_ASSERT(1 == bi->next()); TEST_ASSERT(3 == bi->next()); /* Move the string, kill the original string. */ u_strcpy(movedStr, testStr); u_memset(testStr, 0x20, u_strlen(testStr)); utext_openUChars(&ut2, movedStr, -1, &status); TEST_ASSERT_SUCCESS(status); RuleBasedBreakIterator *returnedBI = &bi->refreshInputText(&ut2, status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT(bi == returnedBI); /* Find the following matches, now working in the moved string. */ TEST_ASSERT(5 == bi->next()); TEST_ASSERT(7 == bi->next()); TEST_ASSERT(8 == bi->next()); TEST_ASSERT(UBRK_DONE == bi->next()); delete bi; utext_close(&ut1); utext_close(&ut2); if (U_SUCCESS(status)) { bi->setText(&ut1, status); TEST_ASSERT_SUCCESS(status); /* Line boundaries will occur before each letter in the original string */ TEST_ASSERT(1 == bi->next()); TEST_ASSERT(3 == bi->next()); /* Move the string, kill the original string. */ u_strcpy(movedStr, testStr); u_memset(testStr, 0x20, u_strlen(testStr)); utext_openUChars(&ut2, movedStr, -1, &status); TEST_ASSERT_SUCCESS(status); RuleBasedBreakIterator *returnedBI = &bi->refreshInputText(&ut2, status); TEST_ASSERT_SUCCESS(status); TEST_ASSERT(bi == returnedBI); /* Find the following matches, now working in the moved string. */ TEST_ASSERT(5 == bi->next()); TEST_ASSERT(7 == bi->next()); TEST_ASSERT(8 == bi->next()); TEST_ASSERT(UBRK_DONE == bi->next()); utext_close(&ut1); utext_close(&ut2); } delete bi; }
static int glist_key(GGadget *g, GEvent *event) { GList *gl = (GList *) g; uint16 keysym = event->u.chr.keysym; int sofar_pos = gl->sofar_pos; int loff, xoff, sel=-1; int refresh = false; if ( event->type == et_charup ) return( false ); if ( !g->takes_input || (g->state!=gs_enabled && g->state!=gs_active && g->state!=gs_focused )) return(false ); if ( gl->ispopup && event->u.chr.keysym == GK_Return ) { GListDoubleClick(gl,false,-1); return( true ); } else if ( gl->ispopup && event->u.chr.keysym == GK_Escape ) { GListClose(gl); return( true ); } if ( event->u.chr.keysym == GK_Return || event->u.chr.keysym == GK_Tab || event->u.chr.keysym == GK_BackTab || event->u.chr.keysym == GK_Escape ) return( false ); GDrawCancelTimer(gl->enduser); gl->enduser = NULL; gl->sofar_pos = 0; loff = 0x80000000; xoff = 0x80000000; sel = -1; if ( keysym == GK_Home || keysym == GK_KP_Home || keysym == GK_Begin || keysym == GK_KP_Begin ) { loff = -gl->loff; xoff = -gl->xoff; sel = 0; } else if ( keysym == GK_End || keysym == GK_KP_End ) { loff = GListTopInWindow(gl,gl->ltot-1)-gl->loff; xoff = -gl->xoff; sel = gl->ltot-1; } else if ( keysym == GK_Up || keysym == GK_KP_Up ) { if (( sel = GListGetFirstSelPos(&gl->g)-1 )<0 ) { /*if ( gl->loff!=0 ) loff = -1; else loff = 0;*/ sel = 0; } } else if ( keysym == GK_Down || keysym == GK_KP_Down ) { if (( sel = GListGetFirstSelPos(&gl->g))!= -1 ) ++sel; else /*if ( gl->loff + GListLinesInWindow(gl,gl->loff)<gl->ltot ) loff = 1; else loff = 0;*/ sel = 0; } else if ( keysym == GK_Left || keysym == GK_KP_Left ) { xoff = -GDrawPointsToPixels(gl->g.base,6); } else if ( keysym == GK_Right || keysym == GK_KP_Right ) { xoff = GDrawPointsToPixels(gl->g.base,6); } else if ( keysym == GK_Page_Up || keysym == GK_KP_Page_Up ) { loff = GListTopInWindow(gl,gl->loff); if ( loff == gl->loff ) /* Normally we leave one line in window from before, except if only one line fits */ loff = GListTopInWindow(gl,gl->loff-1); loff -= gl->loff; if (( sel = GListGetFirstSelPos(&gl->g))!= -1 ) { if (( sel += loff )<0 ) sel = 0; } } else if ( keysym == GK_Page_Down || keysym == GK_KP_Page_Down ) { loff = GListLinesInWindow(gl,gl->loff)-1; if ( loff<=0 ) loff = 1; if ( loff + gl->loff >= gl->ltot ) loff = GListTopInWindow(gl,gl->ltot-1)-gl->loff; if (( sel = GListGetFirstSelPos(&gl->g))!= -1 ) { if (( sel += loff )>=gl->ltot ) sel = gl->ltot-1; } } else if ( keysym == GK_BackSpace && gl->orderer ) { /* ordered lists may be reversed by typing backspace */ gl->backwards = !gl->backwards; GListOrderIt(gl); sel = GListGetFirstSelPos(&gl->g); if ( sel!=-1 ) { int top = GListTopInWindow(gl,gl->ltot-1); gl->loff = sel-1; if ( gl->loff > top ) gl->loff = top; if ( sel-1<0 ) gl->loff = 0; } GScrollBarSetPos(&gl->vsb->g,gl->loff); _ggadget_redraw(&gl->g); return( true ); } else if ( event->u.chr.chars[0]!='\0' && gl->orderer ) { int len = u_strlen(event->u.chr.chars); if ( sofar_pos+len >= gl->sofar_max ) { if ( gl->sofar_max == 0 ) gl->sofar = galloc((gl->sofar_max = len+10) * sizeof(unichar_t)); else gl->sofar = grealloc(gl->sofar,(gl->sofar_max = sofar_pos+len+10)*sizeof(unichar_t)); } u_strcpy(gl->sofar+sofar_pos,event->u.chr.chars); gl->sofar_pos = sofar_pos + len; sel = GListFindPosition(gl,gl->sofar); gl->enduser = GDrawRequestTimer(gl->g.base,GListTypeTime,0,NULL); } if ( loff==0x80000000 && sel>=0 ) { if ( sel>=gl->ltot ) sel = gl->ltot-1; if ( sel<gl->loff ) loff = sel-gl->loff; else if ( sel>=gl->loff+GListLinesInWindow(gl,gl->loff) ) loff = sel-(gl->loff+GListLinesInWindow(gl,gl->loff)-1); } else sel = -1; if ( sel!=-1 ) { int wassel = gl->ti[sel]->selected; refresh = GListAnyOtherSels(gl,sel) || !wassel; GListSelectOne(&gl->g,sel); if ( refresh ) GListSelected(gl,false,sel); } if ( loff!=0x80000000 || xoff!=0x80000000 ) { if ( loff==0x80000000 ) loff = 0; if ( xoff==0x80000000 ) xoff = 0; GListScrollBy(gl,loff,xoff); } if ( refresh ) _ggadget_redraw(g); if ( loff!=0x80000000 || xoff!=0x80000000 || sel!=-1 ) return( true ); return( false ); }