static void TestJB4490(){
static const UChar data[][50]= {
{0x00F5,0x00dE,0x00dF,0x00dD, 0x0000},
{0xFB00,0xFB01}
};
UChar output1[40] = {0};
UChar output2[40] = {0};
int32_t i;
for(i=0; i< sizeof(data)/sizeof(data[0]); i++){
const UChar* src1 = data[i];
int32_t src1Len = u_strlen(src1);
UChar* dest1 = output1;
int32_t dest1Len = 40;
UErrorCode status = U_ZERO_ERROR;
UParseError ps;
UChar* src2 = NULL;
int32_t src2Len = 0;
UChar* dest2 = output2;
int32_t dest2Len = 40;
dest1Len = uidna_toASCII(src1, src1Len, dest1, dest1Len,UIDNA_DEFAULT, &ps, &status);
if(U_FAILURE(status)){
log_err_status(status, "uidna_toUnicode failed with error %s.\n", u_errorName(status));
}
src2 = dest1;
src2Len = dest1Len;
dest2Len = uidna_toUnicode(src2, src2Len, dest2, dest2Len, UIDNA_DEFAULT, &ps, &status);
if(U_FAILURE(status)){
log_err_status(status, "uidna_toUnicode failed with error %s.\n", u_errorName(status));
}
}
}
static void TestJB5273(){
static const char INVALID_DOMAIN_NAME[] = "xn--m\\u00FCller.de";
UChar invalid_idn[25] = {'\0'};
int32_t len = u_unescape(INVALID_DOMAIN_NAME, invalid_idn, strlen(INVALID_DOMAIN_NAME));
UChar output[50] = {'\0'};
UErrorCode status = U_ZERO_ERROR;
UParseError prsError;
int32_t outLen = uidna_toUnicode(invalid_idn, len, output, 50, UIDNA_DEFAULT, &prsError, &status);
if(U_FAILURE(status)){
log_err_status(status, "uidna_toUnicode failed with error: %s\n", u_errorName(status));
}
status = U_ZERO_ERROR;
outLen = uidna_toUnicode(invalid_idn, len, output, 50, UIDNA_USE_STD3_RULES, &prsError, &status);
if(U_FAILURE(status)){
log_err_status(status, "uidna_toUnicode failed with error: %s\n", u_errorName(status));
}
status = U_ZERO_ERROR;
outLen = uidna_IDNToUnicode(invalid_idn, len, output, 50, UIDNA_DEFAULT, &prsError, &status);
if(U_FAILURE(status)){
log_err_status(status, "uidna_toUnicode failed with error: %s\n", u_errorName(status));
}
status = U_ZERO_ERROR;
outLen = uidna_IDNToUnicode(invalid_idn, len, output, 50, UIDNA_USE_STD3_RULES, &prsError, &status);
if(U_FAILURE(status)){
log_err_status(status, "uidna_toUnicode failed with error: %s\n", u_errorName(status));
}
}
static void
TestFCDCrash(void) {
static const char *test[] = {
"Gr\\u00F6\\u00DFe",
"Grossist"
};
UErrorCode status = U_ZERO_ERROR;
UCollator *coll = ucol_open("es", &status);
if(U_FAILURE(status)) {
log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status));
return;
}
ucol_close(coll);
coll = NULL;
ctest_resetICU();
coll = ucol_open("de_DE", &status);
if(U_FAILURE(status)) {
log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status));
return;
}
ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
genericOrderingTest(coll, test, 2);
ucol_close(coll);
}
void TestTwoDigitYearDSTParse()
{
UDateFormat *fullFmt, *fmt;
UErrorCode status = U_ZERO_ERROR;
UChar *pattern;
UDate d;
UChar *s;
int32_t pos;
ctest_setTimeZone(NULL, &status);
pattern=(UChar*)malloc(sizeof(UChar) * (strlen("EEE MMM dd HH:mm:ss.SSS zzz yyyy G")+1 ));
u_uastrcpy(pattern, "EEE MMM dd HH:mm:ss.SSS zzz yyyy G");
fullFmt= udat_open(UDAT_IGNORE, UDAT_IGNORE,"en_US",NULL,0,pattern, u_strlen(pattern),&status);
if(U_FAILURE(status)) {
log_err_status(status, "FAIL: Error in creating a date format using udat_openPattern %s\n",
myErrorName(status) );
}
else {
log_verbose("PASS: creating dateformat using udat_openPattern() succesful\n");
u_uastrcpy(pattern, "dd-MMM-yy h:mm:ss 'o''clock' a z");
fmt= udat_open(UDAT_IGNORE,UDAT_IGNORE,"en_US", NULL, 0,pattern, u_strlen(pattern), &status);
s=(UChar*)malloc(sizeof(UChar) * (strlen("03-Apr-04 2:20:47 o'clock AM PST")+1) );
u_uastrcpy(s, "03-Apr-04 2:20:47 o'clock AM PST");
pos=0;
d = udat_parse(fmt, s, u_strlen(s), &pos, &status);
if (U_FAILURE(status)) {
log_err("FAIL: Could not parse \"%s\"\n", austrdup(s));
} else {
UCalendar *cal = ucal_open(NULL, 0, uloc_getDefault(), UCAL_TRADITIONAL, &status);
if (U_FAILURE(status)) {
log_err_status(status, "FAIL: Could not open calendar: %s\n", u_errorName(status));
} else {
int32_t h;
ucal_setMillis(cal, d, &status);
h = ucal_get(cal, UCAL_HOUR_OF_DAY, &status);
if (U_FAILURE(status)) {
log_err("FAIL: Some calendar operations failed");
} else if (h != 2) {
log_err("FAIL: Parse of \"%s\" returned HOUR_OF_DAY %d\n",
austrdup(s), h);
}
ucal_close(cal);
}
}
udat_close(fullFmt);
udat_close(fmt);
free(s);
}
free(pattern);
ctest_resetTimeZone();
}
/**
* Test for CollationElementIterator previous and next for the whole set of
* unicode characters with normalization on.
*/
static void TestNormalizedUnicodeChar()
{
UChar source[0x100];
UCollator *th_th;
UCollationElements *iter;
UErrorCode status = U_ZERO_ERROR;
UChar codepoint;
UChar *test;
/* thai should have normalization on */
th_th = ucol_open("th_TH", &status);
if (U_FAILURE(status)){
log_err_status(status, "ERROR: in creation of thai collation using ucol_open()\n %s\n",
myErrorName(status));
return;
}
for (codepoint = 1; codepoint < 0xFFFE;)
{
test = source;
while (codepoint % 0xFF != 0)
{
if (u_isdefined(codepoint))
*(test ++) = codepoint;
codepoint ++;
}
if (u_isdefined(codepoint))
*(test ++) = codepoint;
if (codepoint != 0xFFFF)
codepoint ++;
*test = 0;
iter=ucol_openElements(th_th, source, u_strlen(source), &status);
if(U_FAILURE(status)){
log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n",
myErrorName(status));
ucol_close(th_th);
return;
}
backAndForth(iter);
ucol_closeElements(iter);
iter=ucol_openElements(th_th, source, -1, &status);
if(U_FAILURE(status)){
log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n",
myErrorName(status));
ucol_close(th_th);
return;
}
backAndForth(iter);
ucol_closeElements(iter);
}
ucol_close(th_th);
}
static void TestSecondary()
{
UCollationResult expected=UCOL_EQUAL;
int32_t i,j, testAcuteSize;
UErrorCode status = U_ZERO_ERROR;
myCollation = ucol_open("en_US", &status);
if(U_FAILURE(status)){
log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
return;
}
ucol_setStrength(myCollation, UCOL_SECONDARY);
log_verbose("Testing English Collation with Secondary strength\n");
for (i = 43; i < 49 ; i++)
{
doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
}
/*test acute and grave ordering (compare to french collation) */
testAcuteSize = UPRV_LENGTHOF(testAcute);
for (i = 0; i < testAcuteSize; i++)
{
for (j = 0; j < testAcuteSize; j++)
{
if (i < j) expected = UCOL_LESS;
if (i == j) expected = UCOL_EQUAL;
if (i > j) expected = UCOL_GREATER;
doTest(myCollation, testAcute[i], testAcute[j], expected );
}
}
ucol_close(myCollation);
}
static void TestSecondary()
{
int32_t i,j, testAcuteSize;
UCollationResult expected=UCOL_EQUAL;
UErrorCode status = U_ZERO_ERROR;
myCollation = ucol_open("fr_CA", &status);
if(U_FAILURE(status)) {
log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
return;
}
ucol_setAttribute(myCollation, UCOL_STRENGTH, UCOL_SECONDARY, &status);
if(U_FAILURE(status)) {
log_err("ERROR: in creation of rule based collator: %s\n", myErrorName(status));
return;
}
log_verbose("Testing fr_CA Collation with Secondary strength\n");
/*test acute and grave ordering (compare to french collation)*/
testAcuteSize = UPRV_LENGTHOF(testAcute);
for (i = 0; i < testAcuteSize; i++)
{
for (j = 0; j < testAcuteSize; j++)
{
if (i < j) expected = UCOL_LESS;
if (i == j) expected = UCOL_EQUAL;
if (i > j) expected = UCOL_GREATER;
doTest(myCollation, testAcute[i], testAcute[j], expected );
}
}
ucol_close(myCollation);
}
static void
TestIDNToASCII(){
int32_t i;
UChar buf[MAX_DEST_SIZE];
UChar expected[MAX_DEST_SIZE];
UErrorCode status = U_ZERO_ERROR;
int32_t bufLen = 0;
UParseError parseError;
const char* testName="udina_IDNToASCII";
TestFunc func=uidna_IDNToASCII;
for(i=0;i< (int32_t)(sizeof(domainNames)/sizeof(domainNames[0])); i++){
bufLen = (int32_t)strlen(domainNames[i]);
bufLen = u_unescape(domainNames[i],buf, bufLen+1);
func(buf,bufLen,expected,MAX_DEST_SIZE, UIDNA_ALLOW_UNASSIGNED, &parseError,&status);
if(U_FAILURE(status)){
log_err_status(status, "%s failed to convert domainNames[%i].Error: %s \n",testName,i, u_errorName(status));
break;
}
testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func);
/*test toASCII with all labels in the string*/
testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, FALSE, TRUE, func);
if(U_FAILURE(status)){
log_err( "%s failed to convert domainNames[%i].Error: %s \n",testName,i, u_errorName(status));
break;
}
}
}
void TestRunTogetherPattern985()
{
int32_t pos;
UChar *pattern=NULL, *now=NULL, *then=NULL;
UDateFormat *format;
UDate date1, date2;
UErrorCode status = U_ZERO_ERROR;
pattern=(UChar*)malloc(sizeof(UChar) * (strlen("yyyyMMddHHmmssSSS")+1) );
u_uastrcpy(pattern, "yyyyMMddHHmmssSSS");
format = udat_open(UDAT_IGNORE, UDAT_IGNORE, NULL, NULL, 0,pattern, u_strlen(pattern), &status);
if(U_FAILURE(status)){
log_err_status(status, "FAIL: Error in date format construction with pattern: %s\n", myErrorName(status));
return;
}
date1 = ucal_getNow();
now=myDateFormat(format, date1);
log_verbose("%s\n", austrdup(now) );
pos = 0;
date2 = udat_parse(format, now, u_strlen(now), &pos, &status);
if (date2 == 0) log_verbose("Parse stopped at : %d\n", pos);
else then=myDateFormat(format, date2);
log_verbose("%s\n", austrdup(then) );
if (!(date2 == date1)) log_err("FAIL\n");
udat_close(format);
free(pattern);
}
static void TestExtra()
{
int32_t i, j;
int32_t len;
UCollator *myCollation;
UErrorCode status = U_ZERO_ERROR;
static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
UChar rules[sizeof(str)];
len = strlen(str);
u_uastrcpy(rules, str);
myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL, &status);
if(U_FAILURE(status)){
log_err_status(status, "ERROR: in creation of rule based collator :%s\n", myErrorName(status));
return;
}
ucol_setStrength(myCollation, UCOL_TERTIARY);
for (i = 0; i < COUNT_TEST_CASES-1 ; i++)
{
for (j = i + 1; j < COUNT_TEST_CASES; j += 1)
{
doTest(myCollation, testCases[i], testCases[j], UCOL_LESS);
}
}
ucol_close(myCollation);
myCollation = 0;
}
static int dotestconv(const char *name, const char *standard, const char *expected) {
int res = 1;
UErrorCode error;
const char *tag;
error = U_ZERO_ERROR;
tag = ucnv_getCanonicalName(name, standard, &error);
if (tag && !expected) {
log_err("FAIL: Unexpectedly found %s canonical name for %s, got %s\n", standard, name, tag);
res = 0;
}
else if (!tag && expected) {
log_err_status(error, "FAIL: could not find %s canonical name for %s\n", (standard ? "\"\"" : standard), name);
res = 0;
}
else if (expected && (name == tag || uprv_strcmp(expected, tag) != 0)) {
log_err("FAIL: expected %s for %s canonical name for %s, got %s\n", expected, standard, name, tag);
res = 0;
}
else {
log_verbose("PASS: (\"%s\", \"%s\") -> %s == %s \n", name, standard, tag, expected);
}
return res;
}
static void TestPrimary( )
{
int32_t len,i;
UCollator *myCollation;
UErrorCode status=U_ZERO_ERROR;
static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
UChar rules[sizeof(str)];
len = strlen(str);
u_uastrcpy(rules, str);
myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL, &status);
if(U_FAILURE(status)){
log_err_status(status, "ERROR: in creation of rule based collator :%s\n", myErrorName(status));
return;
}
ucol_setStrength(myCollation, UCOL_PRIMARY);
for (i = 17; i < 26 ; i++)
{
doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
}
ucol_close(myCollation);
myCollation = 0;
}
static void TestJB4475(){
static const UChar input[][10] = {
{0x0054,0x0045,0x0053,0x0054,0x0000},/* TEST */
{0x0074,0x0065,0x0073,0x0074,0x0000} /* test */
};
int i;
UChar output[40] = {0};
for(i=0; i< sizeof(input)/sizeof(input[0]); i++){
const UChar* src = input[i];
int32_t srcLen = u_strlen(src);
UChar* dest = output;
int32_t destLen = 40;
UErrorCode status = U_ZERO_ERROR;
UParseError ps;
destLen = uidna_toASCII(src, srcLen, dest, destLen,UIDNA_DEFAULT, &ps, &status);
if(U_FAILURE(status)){
log_err_status(status, "uidna_toASCII failed with error %s.\n", u_errorName(status));
continue;
}
if(u_strncmp(input[i], dest, srcLen)!=0){
log_err("uidna_toASCII did not return the expected output.\n");
}
}
}
/*Test Various format patterns*/
static void TestPatterns(void)
{
int32_t pat_length, i, lneed;
UNumberFormat *fmt;
UChar upat[5];
UChar unewpat[5];
UChar unum[5];
UChar *unewp=NULL;
UChar *str=NULL;
UErrorCode status = U_ZERO_ERROR;
const char* pat[] = { "#.#", "#.", ".#", "#" };
const char* newpat[] = { "0.#", "0.", "#.0", "0" };
const char* num[] = { "0", "0.", ".0", "0" };
log_verbose("\nTesting different format patterns\n");
pat_length = UPRV_LENGTHOF(pat);
for (i=0; i < pat_length; ++i)
{
status = U_ZERO_ERROR;
u_uastrcpy(upat, pat[i]);
fmt= unum_open(UNUM_IGNORE,upat, u_strlen(upat), "en_US",NULL, &status);
if (U_FAILURE(status)) {
log_err_status(status, "FAIL: Number format constructor failed for pattern %s -> %s\n", pat[i], u_errorName(status));
continue;
}
lneed=0;
lneed=unum_toPattern(fmt, FALSE, NULL, lneed, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status= U_ZERO_ERROR;
unewp=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_toPattern(fmt, FALSE, unewp, lneed+1, &status);
}
if(U_FAILURE(status)){
log_err("FAIL: Number format extracting the pattern failed for %s\n", pat[i]);
}
u_uastrcpy(unewpat, newpat[i]);
if(u_strcmp(unewp, unewpat) != 0)
log_err("FAIL: Pattern %s should be transmute to %s; %s seen instead\n", pat[i], newpat[i], austrdup(unewp) );
lneed=0;
lneed=unum_format(fmt, 0, NULL, lneed, NULL, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_format(fmt, 0, str, lneed+1, NULL, &status);
}
if(U_FAILURE(status)) {
log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) );
}
u_uastrcpy(unum, num[i]);
if (u_strcmp(str, unum) != 0)
{
log_err("FAIL: Pattern %s should format zero as %s; %s Seen instead\n", pat[i], num[i], austrdup(str) );
}
free(unewp);
free(str);
unum_close(fmt);
}
}
void Test4061287()
{
UBool ok;
int32_t pos;
UDateFormat *df;
UErrorCode status = U_ZERO_ERROR;
UDate myDate;
UChar pattern[21], dateString[11];
u_uastrcpy(dateString, "35/13/1971");
u_uastrcpy(pattern, "dd/mm/yyyy");
status = U_ZERO_ERROR;
log_verbose("Testing parsing by changing the attribute lenient\n");
df = udat_open(UDAT_IGNORE,UDAT_IGNORE,NULL,NULL,0,pattern, u_strlen(pattern),&status);
if(U_FAILURE(status)) {
log_err_status(status, "ERROR: failure in open pattern of test4061287: %s\n", myErrorName(status));
return;
}
pos=0;
udat_setLenient(df, FALSE);
ok=udat_isLenient(df);
if(ok==TRUE)
log_err("setLenient nor working\n");
ok = FALSE;
myDate = udat_parse(df, dateString, u_strlen(dateString), &pos, &status);
if(U_FAILURE(status))
ok = TRUE;
if(ok!=TRUE)
log_err("Fail: Lenient not working: does lenient parsing in spite of setting Leninent as FALSE ");
udat_close(df);
}
static void
testCompareWithSrc(const UChar* s1, int32_t s1Len,
const UChar* s2, int32_t s2Len,
const char* testName, CompareFunc func,
UBool isEqual){
UErrorCode status = U_ZERO_ERROR;
int32_t retVal = func(s1,-1,s2,-1,UIDNA_DEFAULT,&status);
if(isEqual==TRUE && retVal !=0){
log_err("Did not get the expected result for %s with null termniated strings.\n",testName);
}
if(U_FAILURE(status)){
log_err_status(status, "%s null terminated source failed. Error: %s\n", testName,u_errorName(status));
}
status = U_ZERO_ERROR;
retVal = func(s1,-1,s2,-1,UIDNA_ALLOW_UNASSIGNED,&status);
if(isEqual==TRUE && retVal !=0){
log_err("Did not get the expected result for %s with null termniated strings with options set.\n", testName);
}
if(U_FAILURE(status)){
log_err_status(status, "%s null terminated source and options set failed. Error: %s\n",testName, u_errorName(status));
}
status = U_ZERO_ERROR;
retVal = func(s1,s1Len,s2,s2Len,UIDNA_DEFAULT,&status);
if(isEqual==TRUE && retVal !=0){
log_err("Did not get the expected result for %s with string length.\n",testName);
}
if(U_FAILURE(status)){
log_err_status(status, "%s with string length. Error: %s\n",testName, u_errorName(status));
}
status = U_ZERO_ERROR;
retVal = func(s1,s1Len,s2,s2Len,UIDNA_ALLOW_UNASSIGNED,&status);
if(isEqual==TRUE && retVal !=0){
log_err("Did not get the expected result for %s with string length and options set.\n",testName);
}
if(U_FAILURE(status)){
log_err_status(status, "%s with string length and options set. Error: %s\n", u_errorName(status), testName);
}
}
/*
*### TODO: Add more invalid rules to test all different scenarios.
*
*/
static void
TestInvalidRules(){
#define MAX_ERROR_STATES 2
static const char* rulesArr[MAX_ERROR_STATES] = {
"& C < ch, cH, Ch[this should fail]<d",
"& C < ch, cH, & Ch[variable top]"
};
static const char* preContextArr[MAX_ERROR_STATES] = {
" C < ch, cH, Ch",
"& C < ch, cH",
};
static const char* postContextArr[MAX_ERROR_STATES] = {
"[this should fa",
", & Ch[variable"
};
int i;
for(i = 0;i<MAX_ERROR_STATES;i++){
UChar rules[1000] = { '\0' };
UChar preContextExp[1000] = { '\0' };
UChar postContextExp[1000] = { '\0' };
UParseError parseError;
UErrorCode status = U_ZERO_ERROR;
UCollator* coll=0;
u_charsToUChars(rulesArr[i],rules,uprv_strlen(rulesArr[i])+1);
u_charsToUChars(preContextArr[i],preContextExp,uprv_strlen(preContextArr[i])+1);
u_charsToUChars(postContextArr[i],postContextExp,uprv_strlen(postContextArr[i])+1);
/* clean up stuff in parseError */
u_memset(parseError.preContext,0x0000,U_PARSE_CONTEXT_LEN);
u_memset(parseError.postContext,0x0000,U_PARSE_CONTEXT_LEN);
/* open the rules and test */
coll = ucol_openRules(rules,u_strlen(rules),UCOL_OFF,UCOL_DEFAULT_STRENGTH,&parseError,&status);
(void)coll; /* Suppress set but not used warning. */
if(u_strcmp(parseError.preContext,preContextExp)!=0){
log_err_status(status, "preContext in UParseError for ucol_openRules does not match: \"%s\"\n",
aescstrdup(parseError.preContext, -1));
}
if(u_strcmp(parseError.postContext,postContextExp)!=0){
log_err_status(status, "postContext in UParseError for ucol_openRules does not match: \"%s\"\n",
aescstrdup(parseError.postContext, -1));
}
}
}
void TestAliasConflict(void) {
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *he = NULL;
UResourceBundle *iw = NULL;
const UChar *result = NULL;
int32_t resultLen;
he = ures_open(NULL, "he", &status);
iw = ures_open(NULL, "iw", &status);
if(U_FAILURE(status)) {
log_err_status(status, "Failed to get resource with %s\n", myErrorName(status));
}
ures_close(iw);
result = ures_getStringByKey(he, "ExemplarCharacters", &resultLen, &status);
if(U_FAILURE(status) || result == NULL) {
log_err_status(status, "Failed to get resource with %s\n", myErrorName(status));
}
ures_close(he);
}
static void
TestJitterbug1098(){
UChar rule[1000];
UCollator* c1 = NULL;
UErrorCode status = U_ZERO_ERROR;
UParseError parseError;
char preContext[200]={0};
char postContext[200]={0};
int i=0;
const char* rules[] = {
"&''<\\\\",
"&\\'<\\\\",
"&\\\"<'\\'",
"&'\"'<\\'",
NULL
};
const UCollationResult results1098[] = {
UCOL_LESS,
UCOL_LESS,
UCOL_LESS,
UCOL_LESS,
};
const UChar input[][2]= {
{0x0027,0x005c},
{0x0027,0x005c},
{0x0022,0x005c},
{0x0022,0x0027},
};
UChar X[2] ={0};
UChar Y[2] ={0};
u_memset(parseError.preContext,0x0000,U_PARSE_CONTEXT_LEN);
u_memset(parseError.postContext,0x0000,U_PARSE_CONTEXT_LEN);
for(;rules[i]!=0;i++){
u_uastrcpy(rule, rules[i]);
c1 = ucol_openRules(rule, u_strlen(rule), UCOL_OFF, UCOL_DEFAULT_STRENGTH, &parseError, &status);
if(U_FAILURE(status)){
log_err_status(status, "Could not parse the rules syntax. Error: %s\n", u_errorName(status));
if (status == U_PARSE_ERROR) {
u_UCharsToChars(parseError.preContext,preContext,20);
u_UCharsToChars(parseError.postContext,postContext,20);
log_verbose("\n\tPre-Context: %s \n\tPost-Context:%s \n",preContext,postContext);
}
return;
}
X[0] = input[i][0];
Y[0] = input[i][1];
doTest(c1,X,Y,results1098[i]);
ucol_close(c1);
}
}
U_CFUNC UBool assertSuccessCheck(const char* msg, UErrorCode* ec, UBool possibleDataError) {
U_ASSERT(ec!=NULL);
if (U_FAILURE(*ec)) {
if (possibleDataError) {
log_data_err("FAIL: %s (%s)\n", msg, u_errorName(*ec));
} else {
log_err_status(*ec, "FAIL: %s (%s)\n", msg, u_errorName(*ec));
}
return FALSE;
}
return TRUE;
}
void TestQuotePattern161()
{
UDateFormat *format;
UCalendar *cal;
UDate currentTime_1;
UChar *pattern, *tzID, *exp;
UChar *dateString;
UErrorCode status = U_ZERO_ERROR;
const char* expStr = "04/13/1999 at 10:42:28 AM ";
ctest_setTimeZone(NULL, &status);
pattern=(UChar*)malloc(sizeof(UChar) * (strlen("MM/dd/yyyy 'at' hh:mm:ss a zzz")+1) );
u_uastrcpy(pattern, "MM/dd/yyyy 'at' hh:mm:ss a zzz");
/* this is supposed to open default date format, but later on it treats it like it is "en_US"
- very bad if you try to run the tests on machine where default locale is NOT "en_US" */
/* format= udat_openPattern(pattern, u_strlen(pattern), NULL, &status); */
format= udat_open(UDAT_IGNORE, UDAT_IGNORE,"en_US", NULL, 0,pattern, u_strlen(pattern), &status);
if(U_FAILURE(status)){
log_err_status(status, "error in udat_open: %s\n", myErrorName(status));
return;
}
tzID=(UChar*)malloc(sizeof(UChar) * 4);
u_uastrcpy(tzID, "PST");
/* this is supposed to open default date format, but later on it treats it like it is "en_US"
- very bad if you try to run the tests on machine where default locale is NOT "en_US" */
/* cal=ucal_open(tzID, u_strlen(tzID), NULL, UCAL_TRADITIONAL, &status); */
cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
if(U_FAILURE(status)){ log_err("error in ucal_open cal : %s\n", myErrorName(status)); }
ucal_setDateTime(cal, 1999, UCAL_APRIL, 13, 10, 42, 28, &status);
currentTime_1 = ucal_getMillis(cal, &status);
dateString = myDateFormat(format, currentTime_1);
exp=(UChar*)malloc(sizeof(UChar) * (strlen(expStr) + 1) );
u_uastrcpy(exp, expStr);
log_verbose("%s\n", austrdup(dateString) );
if(u_strncmp(dateString, exp, (int32_t)strlen(expStr)) !=0)
log_err("Error in formatting a pattern with single quotes\n");
udat_close(format);
ucal_close(cal);
free(exp);
free(tzID);
free(pattern);
ctest_resetTimeZone();
}
static void TestFallback()
{
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *fr_FR = NULL;
UResourceBundle *subResource = NULL;
const UChar *junk; /* ignored */
int32_t resultLen;
log_verbose("Opening fr_FR..");
fr_FR = ures_open(NULL, "fr_FR", &status);
if(U_FAILURE(status))
{
log_err_status(status, "Couldn't open fr_FR - %s\n", u_errorName(status));
return;
}
status = U_ZERO_ERROR;
/* clear it out.. just do some calls to get the gears turning */
junk = ures_getStringByKey(fr_FR, "LocaleID", &resultLen, &status);
(void)junk; /* Suppress set but not used warning. */
status = U_ZERO_ERROR;
junk = ures_getStringByKey(fr_FR, "LocaleString", &resultLen, &status);
status = U_ZERO_ERROR;
junk = ures_getStringByKey(fr_FR, "LocaleID", &resultLen, &status);
status = U_ZERO_ERROR;
/* OK first one. This should be a Default value. */
subResource = ures_getByKey(fr_FR, "layout", NULL, &status);
if(status != U_USING_DEFAULT_WARNING)
{
log_data_err("Expected U_USING_DEFAULT_ERROR when trying to get layout from fr_FR, got %s\n",
u_errorName(status));
}
ures_close(subResource);
status = U_ZERO_ERROR;
/* and this is a Fallback, to fr */
junk = ures_getStringByKey(fr_FR, "ExemplarCharacters", &resultLen, &status);
if(status != U_USING_FALLBACK_WARNING)
{
log_data_err("Expected U_USING_FALLBACK_ERROR when trying to get ExemplarCharacters from fr_FR, got %s\n",
u_errorName(status));
}
status = U_ZERO_ERROR;
ures_close(fr_FR);
}
static void TestBreakIteratorTailoring(void) {
const RBBITailoringTest * testPtr;
for (testPtr = tailoringTests; testPtr->locale != NULL; ++testPtr) {
UErrorCode status = U_ZERO_ERROR;
UBreakIterator* ubrkiter = ubrk_open(testPtr->type, testPtr->locale, testPtr->test, -1, &status);
if ( U_SUCCESS(status) ) {
int32_t offset, offsindx;
UBool foundError;
foundError = FALSE;
for (offsindx = 0; (offset = ubrk_next(ubrkiter)) != UBRK_DONE; ++offsindx) {
if (!foundError && offsindx >= testPtr->numOffsets) {
log_err("FAIL: locale %s, break type %d, ubrk_next expected UBRK_DONE, got %d\n",
testPtr->locale, testPtr->type, offset);
foundError = TRUE;
} else if (!foundError && offset != testPtr->offsFwd[offsindx]) {
log_err("FAIL: locale %s, break type %d, ubrk_next expected %d, got %d\n",
testPtr->locale, testPtr->type, testPtr->offsFwd[offsindx], offset);
foundError = TRUE;
}
}
if (!foundError && offsindx < testPtr->numOffsets) {
log_err("FAIL: locale %s, break type %d, ubrk_next expected %d, got UBRK_DONE\n",
testPtr->locale, testPtr->type, testPtr->offsFwd[offsindx]);
}
foundError = FALSE;
for (offsindx = 0; (offset = ubrk_previous(ubrkiter)) != UBRK_DONE; ++offsindx) {
if (!foundError && offsindx >= testPtr->numOffsets) {
log_err("FAIL: locale %s, break type %d, ubrk_previous expected UBRK_DONE, got %d\n",
testPtr->locale, testPtr->type, offset);
foundError = TRUE;
} else if (!foundError && offset != testPtr->offsRev[offsindx]) {
log_err("FAIL: locale %s, break type %d, ubrk_previous expected %d, got %d\n",
testPtr->locale, testPtr->type, testPtr->offsRev[offsindx], offset);
foundError = TRUE;
}
}
if (!foundError && offsindx < testPtr->numOffsets) {
log_err("FAIL: locale %s, break type %d, ubrk_previous expected %d, got UBRK_DONE\n",
testPtr->locale, testPtr->type, testPtr->offsRev[offsindx]);
}
ubrk_close(ubrkiter);
} else {
log_err_status(status, "FAIL: locale %s, break type %d, ubrk_open status: %s\n", testPtr->locale, testPtr->type, u_errorName(status));
}
}
}
static void TestJB581(void)
{
int32_t bufferLen = 0;
UChar source [100];
UChar target [100];
UCollationResult result = UCOL_EQUAL;
uint8_t sourceKeyArray [100];
uint8_t targetKeyArray [100];
int32_t sourceKeyOut = 0,
targetKeyOut = 0;
UCollator *myCollator = 0;
UErrorCode status = U_ZERO_ERROR;
/*u_uastrcpy(source, "This is a test.");*/
/*u_uastrcpy(target, "THISISATEST.");*/
u_uastrcpy(source, "THISISATEST.");
u_uastrcpy(target, "Thisisatest.");
myCollator = ucol_open("en_US", &status);
if (U_FAILURE(status)){
log_err_status(status, "ERROR: Failed to create the collator : %s\n", u_errorName(status));
return;
}
result = ucol_strcoll(myCollator, source, -1, target, -1);
/* result is 1, secondary differences only for ignorable space characters*/
if (result != 1)
{
log_err("Comparing two strings with only secondary differences in C failed.\n");
}
/* To compare them with just primary differences */
ucol_setStrength(myCollator, UCOL_PRIMARY);
result = ucol_strcoll(myCollator, source, -1, target, -1);
/* result is 0 */
if (result != 0)
{
log_err("Comparing two strings with no differences in C failed.\n");
}
/* Now, do the same comparison with keys */
sourceKeyOut = ucol_getSortKey(myCollator, source, -1, sourceKeyArray, 100);
(void)sourceKeyOut; /* Suppress set but not used warning. */
targetKeyOut = ucol_getSortKey(myCollator, target, -1, targetKeyArray, 100);
bufferLen = ((targetKeyOut > 100) ? 100 : targetKeyOut);
if (memcmp(sourceKeyArray, targetKeyArray, bufferLen) != 0)
{
log_err("Comparing two strings with sort keys in C failed.\n");
}
ucol_close(myCollator);
}
static void TestGenderInfo(void) {
UErrorCode status = U_ZERO_ERROR;
const UGenderInfo* actual_gi = ugender_getInstance("fr_CA", &status);
UGender actual;
if (U_FAILURE(status)) {
log_err_status(status, "Fail to create UGenderInfo - %s (Are you missing data?)", u_errorName(status));
return;
}
actual = ugender_getListGender(actual_gi, kAllFemale, UPRV_LENGTHOF(kAllFemale), &status);
if (U_FAILURE(status)) {
log_err("Fail to get gender of list - %s\n", u_errorName(status));
return;
}
if (actual != UGENDER_FEMALE) {
log_err("Expected UGENDER_FEMALE got %d\n", actual);
}
}
static void TestPrimary()
{
int32_t i;
UErrorCode status = U_ZERO_ERROR;
myCollation = ucol_open("fi_FI@collation=standard", &status);
if(U_FAILURE(status)){
log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
}
log_verbose("Testing Finnish Collation with Primary strength\n");
ucol_setStrength(myCollation, UCOL_PRIMARY);
for (i = 4; i < 5; i++)
{
doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
}
ucol_close(myCollation);
}
static void TestTertiary( )
{
int32_t i;
UErrorCode status = U_ZERO_ERROR;
myCollation = ucol_open("es_ES", &status);
if(U_FAILURE(status)){
log_err_status(status, "ERROR: %s: in creation of rule based collator: %s\n", __FILE__, myErrorName(status));
return;
}
log_verbose("Testing Spanish Collation with Tertiary strength\n");
ucol_setStrength(myCollation, UCOL_TERTIARY);
for (i = 0; i < 5 ; i++)
{
doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
}
ucol_close(myCollation);
}
static int dotestname(const char *name, const char *standard, const char *expected) {
int res = 1;
UErrorCode error;
const char *tag;
error = U_ZERO_ERROR;
tag = ucnv_getStandardName(name, standard, &error);
if (!tag && expected) {
log_err_status(error, "FAIL: could not find %s standard name for %s\n", standard, name);
res = 0;
} else if (expected && (name == tag || uprv_strcmp(expected, tag))) {
log_err("FAIL: expected %s for %s standard name for %s, got %s\n", expected, standard, name, tag);
res = 0;
}
return res;
}
UBool ctest_resetICU() {
UErrorCode status = U_ZERO_ERROR;
char *dataDir = safeGetICUDataDirectory();
u_cleanup();
if (!initArgs(gOrigArgc, gOrigArgv, NULL, NULL)) {
/* Error already displayed. */
return FALSE;
}
u_setDataDirectory(dataDir);
free(dataDir);
u_init(&status);
if (U_FAILURE(status)) {
log_err_status(status, "u_init failed with %s\n", u_errorName(status));
return FALSE;
}
return TRUE;
}
static void TestTertiary( )
{
int32_t i;
UErrorCode status = U_ZERO_ERROR;
myCollation = ucol_open("ja_JP", &status);
if(U_FAILURE(status)){
log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
return;
}
log_verbose("Testing Kanna(Japan) Collation with Tertiary strength\n");
ucol_setStrength(myCollation, UCOL_TERTIARY);
ucol_setAttribute(myCollation, UCOL_CASE_LEVEL, UCOL_ON, &status);
for (i = 0; i < 6 ; i++)
{
doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
}
ucol_close(myCollation);
}
