void DateFormatRegressionTest::Test1684(void)
{
// July 2001 August 2001 January 2002
// Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6 7 1 2 3 4 1 2 3 4 5
// 8 9 10 11 12 13 14 5 6 7 8 9 10 11 6 7 8 9 10 11 12
// 15 16 17 18 19 20 21 12 13 14 15 16 17 18 13 14 15 16 17 18 19
// 22 23 24 25 26 27 28 19 20 21 22 23 24 25 20 21 22 23 24 25 26
// 29 30 31 26 27 28 29 30 31 27 28 29 30 31
Test1684Data *tests[] = {
new Test1684Data(2001, 8, 6, 2001,8,2,UCAL_MONDAY, "2001 08 02 Mon", NULL),
new Test1684Data(2001, 8, 7, 2001,8,2,UCAL_TUESDAY, "2001 08 02 Tue", NULL),
new Test1684Data(2001, 8, 5,/*12,*/ 2001,8,2,UCAL_SUNDAY, "2001 08 02 Sun", NULL),
new Test1684Data(2001, 8,6, /*7, 30,*/ 2001,7,6,UCAL_MONDAY, "2001 07 06 Mon", "2001 08 02 Mon"),
new Test1684Data(2001, 8,7, /*7, 31,*/ 2001,7,6,UCAL_TUESDAY, "2001 07 06 Tue", "2001 08 02 Tue"),
new Test1684Data(2001, 8, 5, 2001,7,6,UCAL_SUNDAY, "2001 07 06 Sun", "2001 08 02 Sun"),
new Test1684Data(2001, 7, 30, 2001,8,1,UCAL_MONDAY, "2001 08 01 Mon", "2001 07 05 Mon"),
new Test1684Data(2001, 7, 31, 2001,8,1,UCAL_TUESDAY, "2001 08 01 Tue", "2001 07 05 Tue"),
new Test1684Data(2001, 7,29, /*8, 5,*/ 2001,8,1,UCAL_SUNDAY, "2001 08 01 Sun", "2001 07 05 Sun"),
new Test1684Data(2001, 12, 31, 2001,12,6,UCAL_MONDAY, "2001 12 06 Mon", NULL),
new Test1684Data(2002, 1, 1, 2002,1,1,UCAL_TUESDAY, "2002 01 01 Tue", NULL),
new Test1684Data(2002, 1, 2, 2002,1,1,UCAL_WEDNESDAY, "2002 01 01 Wed", NULL),
new Test1684Data(2002, 1, 3, 2002,1,1,UCAL_THURSDAY, "2002 01 01 Thu", NULL),
new Test1684Data(2002, 1, 4, 2002,1,1,UCAL_FRIDAY, "2002 01 01 Fri", NULL),
new Test1684Data(2002, 1, 5, 2002,1,1,UCAL_SATURDAY, "2002 01 01 Sat", NULL),
new Test1684Data(2001,12,30, /*2002, 1, 6,*/ 2002,1,1,UCAL_SUNDAY, "2002 01 01 Sun", "2001 12 06 Sun")
};
#define kTest1684Count ((int32_t)(sizeof(tests)/sizeof(tests[0])))
int32_t pass = 0, error = 0, warning = 0;
int32_t i;
UErrorCode status = U_ZERO_ERROR;
UnicodeString pattern("yyyy MM WW EEE","");
Calendar *cal = new GregorianCalendar(status);
SimpleDateFormat *sdf = new SimpleDateFormat(pattern,status);
if (U_FAILURE(status)) {
dataerrln("Error constructing SimpleDateFormat");
for(i=0;i<kTest1684Count;i++) {
delete tests[i];
}
delete cal;
delete sdf;
return;
}
cal->setFirstDayOfWeek(UCAL_SUNDAY);
cal->setMinimalDaysInFirstWeek(1);
sdf->adoptCalendar(cal);
cal = sdf->getCalendar()->clone(); // sdf may have deleted calendar
if(!cal || !sdf || U_FAILURE(status)) {
errln(UnicodeString("Error setting up test: ") + u_errorName(status));
}
for (i = 0; i < kTest1684Count; ++i) {
Test1684Data &test = *(tests[i]);
logln(UnicodeString("#") + i + UnicodeString("\n-----\nTesting round trip of ") + test.year +
" " + (test.month + 1) +
" " + test.date +
" (written as) " + test.data);
cal->clear();
cal->set(test.year, test.month, test.date);
UDate ms = cal->getTime(status);
cal->clear();
cal->set(UCAL_YEAR, test.womyear);
cal->set(UCAL_MONTH, test.wommon);
cal->set(UCAL_WEEK_OF_MONTH, test.wom);
cal->set(UCAL_DAY_OF_WEEK, test.dow);
UDate ms2 = cal->getTime(status);
if (ms2 != ms) {
errln((UnicodeString)"\nError: GregorianUCAL_DOM gave " + ms +
"\n GregorianUCAL_WOM gave " + ms2);
error++;
} else {
pass++;
}
ms2 = sdf->parse(test.data, status);
if(U_FAILURE(status)) {
errln("parse exception: " + UnicodeString(u_errorName(status)));
}
if (ms2!=ms) {
errln((UnicodeString)"\nError: GregorianCalendar gave " + ms +
"\n SimpleDateFormat.parse gave " + ms2);
error++;
} else {
pass++;
}
UnicodeString result;
sdf->format(ms, result);
if (result != test.normalized) {
errln("\nWarning: format of '" + test.data + "' gave" +
"\n '" + result + "'" +
"\n expected '" + test.normalized + "'");
warning++;
} else {
pass++;
}
UDate ms3;
ms3 = sdf->parse(result, status);
if(U_FAILURE(status)) {
errln("parse exception 2: " + (UnicodeString)u_errorName(status));
}
if (ms3!=ms) {
error++;
errln((UnicodeString)"\nError: Re-parse of '" + result + "' gave time of " +
"\n " + ms3 +
"\n not " + ms);
} else {
pass++;
}
}
UnicodeString info
= UnicodeString("Passed: ") + pass + ", Warnings: " + warning + ", Errors: " + error;
if (error > 0) {
errln(info);
} else {
logln(info);
}
for(i=0;i<kTest1684Count;i++) {
delete tests[i];
}
delete cal;
delete sdf;
}
static int init_inode_xattrs(struct inode *inode)
{
struct erofs_vnode *const vi = EROFS_V(inode);
struct xattr_iter it;
unsigned int i;
struct erofs_xattr_ibody_header *ih;
struct super_block *sb;
struct erofs_sb_info *sbi;
bool atomic_map;
int ret = 0;
/* the most case is that xattrs of this inode are initialized. */
if (test_bit(EROFS_V_EA_INITED_BIT, &vi->flags))
return 0;
if (wait_on_bit_lock(&vi->flags, EROFS_V_BL_XATTR_BIT, TASK_KILLABLE))
return -ERESTARTSYS;
/* someone has initialized xattrs for us? */
if (test_bit(EROFS_V_EA_INITED_BIT, &vi->flags))
goto out_unlock;
/*
* bypass all xattr operations if ->xattr_isize is not greater than
* sizeof(struct erofs_xattr_ibody_header), in detail:
* 1) it is not enough to contain erofs_xattr_ibody_header then
* ->xattr_isize should be 0 (it means no xattr);
* 2) it is just to contain erofs_xattr_ibody_header, which is on-disk
* undefined right now (maybe use later with some new sb feature).
*/
if (vi->xattr_isize == sizeof(struct erofs_xattr_ibody_header)) {
errln("xattr_isize %d of nid %llu is not supported yet",
vi->xattr_isize, vi->nid);
ret = -ENOTSUPP;
goto out_unlock;
} else if (vi->xattr_isize < sizeof(struct erofs_xattr_ibody_header)) {
if (unlikely(vi->xattr_isize)) {
DBG_BUGON(1);
ret = -EIO;
goto out_unlock; /* xattr ondisk layout error */
}
ret = -ENOATTR;
goto out_unlock;
}
sb = inode->i_sb;
sbi = EROFS_SB(sb);
it.blkaddr = erofs_blknr(iloc(sbi, vi->nid) + vi->inode_isize);
it.ofs = erofs_blkoff(iloc(sbi, vi->nid) + vi->inode_isize);
it.page = erofs_get_inline_page(inode, it.blkaddr);
if (IS_ERR(it.page)) {
ret = PTR_ERR(it.page);
goto out_unlock;
}
/* read in shared xattr array (non-atomic, see kmalloc below) */
it.kaddr = kmap(it.page);
atomic_map = false;
ih = (struct erofs_xattr_ibody_header *)(it.kaddr + it.ofs);
vi->xattr_shared_count = ih->h_shared_count;
vi->xattr_shared_xattrs = kmalloc_array(vi->xattr_shared_count,
sizeof(uint), GFP_KERNEL);
if (!vi->xattr_shared_xattrs) {
xattr_iter_end(&it, atomic_map);
ret = -ENOMEM;
goto out_unlock;
}
/* let's skip ibody header */
it.ofs += sizeof(struct erofs_xattr_ibody_header);
for (i = 0; i < vi->xattr_shared_count; ++i) {
if (unlikely(it.ofs >= EROFS_BLKSIZ)) {
/* cannot be unaligned */
BUG_ON(it.ofs != EROFS_BLKSIZ);
xattr_iter_end(&it, atomic_map);
it.page = erofs_get_meta_page(sb, ++it.blkaddr,
S_ISDIR(inode->i_mode));
if (IS_ERR(it.page)) {
kfree(vi->xattr_shared_xattrs);
vi->xattr_shared_xattrs = NULL;
ret = PTR_ERR(it.page);
goto out_unlock;
}
it.kaddr = kmap_atomic(it.page);
atomic_map = true;
it.ofs = 0;
}
vi->xattr_shared_xattrs[i] =
le32_to_cpu(*(__le32 *)(it.kaddr + it.ofs));
it.ofs += sizeof(__le32);
}
xattr_iter_end(&it, atomic_map);
set_bit(EROFS_V_EA_INITED_BIT, &vi->flags);
out_unlock:
clear_and_wake_up_bit(EROFS_V_BL_XATTR_BIT, &vi->flags);
return ret;
}
void
CalendarLimitTest::doLimitsTest(Calendar& cal,
const int32_t* fieldsToTest,
UDate startDate,
int32_t testDuration) {
static const int32_t FIELDS[] = {
UCAL_ERA,
UCAL_YEAR,
UCAL_MONTH,
UCAL_WEEK_OF_YEAR,
UCAL_WEEK_OF_MONTH,
UCAL_DAY_OF_MONTH,
UCAL_DAY_OF_YEAR,
UCAL_DAY_OF_WEEK_IN_MONTH,
UCAL_YEAR_WOY,
UCAL_EXTENDED_YEAR,
-1,
};
static const char* FIELD_NAME[] = {
"ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH",
"DAY_OF_MONTH", "DAY_OF_YEAR", "DAY_OF_WEEK",
"DAY_OF_WEEK_IN_MONTH", "AM_PM", "HOUR", "HOUR_OF_DAY",
"MINUTE", "SECOND", "MILLISECOND", "ZONE_OFFSET",
"DST_OFFSET", "YEAR_WOY", "DOW_LOCAL", "EXTENDED_YEAR",
"JULIAN_DAY", "MILLISECONDS_IN_DAY",
"IS_LEAP_MONTH"
};
UErrorCode status = U_ZERO_ERROR;
int32_t i, j;
UnicodeString ymd;
GregorianCalendar greg(status);
if (failure(status, "new GregorianCalendar")) {
return;
}
greg.setTime(startDate, status);
if (failure(status, "GregorianCalendar::setTime")) {
return;
}
logln((UnicodeString)"Start: " + startDate);
if (fieldsToTest == NULL) {
fieldsToTest = FIELDS;
}
// Keep a record of minima and maxima that we actually see.
// These are kept in an array of arrays of hashes.
int32_t limits[UCAL_FIELD_COUNT][4];
for (j = 0; j < UCAL_FIELD_COUNT; j++) {
limits[j][0] = INT32_MAX;
limits[j][1] = INT32_MIN;
limits[j][2] = INT32_MAX;
limits[j][3] = INT32_MIN;
}
// This test can run for a long time; show progress.
UDate millis = ucal_getNow();
UDate mark = millis + 5000; // 5 sec
millis -= testDuration * 1000; // stop time if testDuration<0
for (i = 0;
testDuration > 0 ? i < testDuration
: ucal_getNow() < millis;
++i) {
if (ucal_getNow() >= mark) {
logln((UnicodeString)"(" + i + " days)");
mark += 5000; // 5 sec
}
cal.setTime(greg.getTime(status), status);
cal.setMinimalDaysInFirstWeek(1);
if (failure(status, "Calendar set/getTime")) {
return;
}
for (j = 0; fieldsToTest[j] >= 0; ++j) {
UCalendarDateFields f = (UCalendarDateFields)fieldsToTest[j];
int32_t v = cal.get(f, status);
int32_t minActual = cal.getActualMinimum(f, status);
int32_t maxActual = cal.getActualMaximum(f, status);
int32_t minLow = cal.getMinimum(f);
int32_t minHigh = cal.getGreatestMinimum(f);
int32_t maxLow = cal.getLeastMaximum(f);
int32_t maxHigh = cal.getMaximum(f);
if (limits[j][0] > minActual) {
// the minimum
limits[j][0] = minActual;
}
if (limits[j][1] < minActual) {
// the greatest minimum
limits[j][1] = minActual;
}
if (limits[j][2] > maxActual) {
// the least maximum
limits[j][2] = maxActual;
}
if (limits[j][3] < maxActual) {
// the maximum
limits[j][3] = maxActual;
}
if (minActual < minLow || minActual > minHigh) {
errln((UnicodeString)"Fail: [" + cal.getType() + "] " +
ymdToString(cal, ymd) +
" Range for min of " + FIELD_NAME[f] + "(" + f +
")=" + minLow + ".." + minHigh +
", actual_min=" + minActual);
}
if (maxActual < maxLow || maxActual > maxHigh) {
errln((UnicodeString)"Fail: [" + cal.getType() + "] " +
ymdToString(cal, ymd) +
" Range for max of " + FIELD_NAME[f] + "(" + f +
")=" + maxLow + ".." + maxHigh +
", actual_max=" + maxActual);
}
if (v < minActual || v > maxActual) {
errln((UnicodeString)"Fail: [" + cal.getType() + "] " +
ymdToString(cal, ymd) +
" " + FIELD_NAME[f] + "(" + f + ")=" + v +
", actual range=" + minActual + ".." + maxActual +
", allowed=(" + minLow + ".." + minHigh + ")..(" +
maxLow + ".." + maxHigh + ")");
}
}
greg.add(UCAL_DAY_OF_YEAR, 1, status);
if (failure(status, "Calendar::add")) {
return;
}
}
// Check actual maxima and minima seen against ranges returned
// by API.
UnicodeString buf;
for (j = 0; fieldsToTest[j] >= 0; ++j) {
int32_t rangeLow, rangeHigh;
UBool fullRangeSeen = TRUE;
UCalendarDateFields f = (UCalendarDateFields)fieldsToTest[j];
buf.remove();
buf.append((UnicodeString)"[" + cal.getType() + "] " + FIELD_NAME[f]);
// Minumum
rangeLow = cal.getMinimum(f);
rangeHigh = cal.getGreatestMinimum(f);
if (limits[j][0] != rangeLow || limits[j][1] != rangeHigh) {
fullRangeSeen = FALSE;
}
buf.append((UnicodeString)" minima range=" + rangeLow + ".." + rangeHigh);
buf.append((UnicodeString)" minima actual=" + limits[j][0] + ".." + limits[j][1]);
// Maximum
rangeLow = cal.getLeastMaximum(f);
rangeHigh = cal.getMaximum(f);
if (limits[j][2] != rangeLow || limits[j][3] != rangeHigh) {
fullRangeSeen = FALSE;
}
buf.append((UnicodeString)" maxima range=" + rangeLow + ".." + rangeHigh);
buf.append((UnicodeString)" maxima actual=" + limits[j][2] + ".." + limits[j][3]);
if (fullRangeSeen) {
logln((UnicodeString)"OK: " + buf);
} else {
// This may or may not be an error -- if the range of dates
// we scan over doesn't happen to contain a minimum or
// maximum, it doesn't mean some other range won't.
logln((UnicodeString)"Warning: " + buf);
}
}
logln((UnicodeString)"End: " + greg.getTime(status));
}
/**
* Test various generic API methods of PluralFormat for Basic usage.
*/
void PluralFormatTest::pluralFormatBasicTest(/*char *par*/)
{
UErrorCode status[8];
PluralFormat* plFmt[8];
Locale locale = Locale::getDefault();
UnicodeString otherPattern = UnicodeString("other{#}");
UnicodeString message=UnicodeString("ERROR: PluralFormat basic test");
// ========= Test constructors
logln(" Testing PluralFormat constructors ...");
status[0] = U_ZERO_ERROR;
PluralRules* plRules = PluralRules::createDefaultRules(status[0]);
status[0] = U_ZERO_ERROR;
NumberFormat *numFmt = NumberFormat::createInstance(status[0]);
if (U_FAILURE(status[0])) {
dataerrln("ERROR: Could not create NumberFormat instance with default locale ");
}
for (int32_t i=0; i< 8; ++i) {
status[i] = U_ZERO_ERROR;
}
plFmt[0] = new PluralFormat(status[0]);
plFmt[1] = new PluralFormat(*plRules, status[1]);
plFmt[2] = new PluralFormat(locale, status[2]);
plFmt[3] = new PluralFormat(locale, *plRules, status[3]);
plFmt[4] = new PluralFormat(otherPattern, status[4]);
plFmt[5] = new PluralFormat(*plRules, otherPattern, status[5]);
plFmt[6] = new PluralFormat(locale, otherPattern, status[6]);
plFmt[7] = new PluralFormat(locale, *plRules, otherPattern, status[7]);
for (int32_t i=0; i< 8; ++i) {
if (U_SUCCESS(status[i])) {
numberFormatTest(plFmt[i], numFmt, 1, 12, NULL, NULL, FALSE, &message);
numberFormatTest(plFmt[i], numFmt, 100, 112, NULL, NULL, FALSE, &message);
}
else {
dataerrln("ERROR: PluralFormat constructor failed!");
}
delete plFmt[i];
}
// ======= Test clone, assignment operator && == operator.
plFmt[0]= new PluralFormat(status[0]);
plFmt[0]->setNumberFormat(numFmt,status[0]);
UnicodeString us = UnicodeString("");
plFmt[0]->toPattern(us);
plFmt[1]= new PluralFormat(locale, status[1]);
if ( U_SUCCESS(status[0]) && U_SUCCESS(status[1]) ) {
*plFmt[1] = *plFmt[0];
if (plFmt[1]!=NULL) {
if ( *plFmt[1] != *plFmt[0] ) {
errln("ERROR: clone plural format test failed!");
}
}
}
else {
dataerrln("ERROR: PluralFormat constructor failed! - [0]%s [1]%s", u_errorName(status[0]), u_errorName(status[1]));
}
delete plFmt[0];
status[0] = U_ZERO_ERROR;
plFmt[0]= new PluralFormat(locale, status[0]);
if ( U_SUCCESS(status[0]) ) {
*plFmt[1] = *plFmt[0];
if (plFmt[1]!=NULL) {
if ( *plFmt[1] != *plFmt[0] ) {
errln("ERROR: assignment operator test failed!");
}
}
}
else {
dataerrln("ERROR: PluralFormat constructor failed! - %s", u_errorName(status[1]));
}
if ( U_SUCCESS(status[1]) ) {
plFmt[2] = (PluralFormat*) plFmt[1]->clone();
if (plFmt[1]!=NULL) {
if ( *plFmt[1] != *plFmt[2] ) {
errln("ERROR: clone function test failed!");
}
}
delete plFmt[1];
delete plFmt[2];
}
else {
dataerrln("ERROR: PluralFormat clone failed! - %s", u_errorName(status[1]));
}
delete plFmt[0];
delete numFmt;
delete plRules;
// Tests parseObject
UErrorCode stat = U_ZERO_ERROR;
PluralFormat *pf = new PluralFormat(stat);
Formattable *f = new Formattable();
ParsePosition *pp = new ParsePosition();
pf->parseObject((UnicodeString)"",*f,*pp);
if(U_FAILURE(stat)) {
dataerrln("ERROR: PluralFormat::parseObject: %s", u_errorName(stat));
}
delete pf;
delete f;
delete pp;
}
void CollationServiceTest::TestRegister()
{
#if !UCONFIG_NO_SERVICE
// register a singleton
const Locale& FR = Locale::getFrance();
const Locale& US = Locale::getUS();
const Locale US_FOO("en", "US", "FOO");
UErrorCode status = U_ZERO_ERROR;
Collator* frcol = Collator::createInstance(FR, status);
Collator* uscol = Collator::createInstance(US, status);
if(U_FAILURE(status)) {
errcheckln(status, "Failed to create collators with %s", u_errorName(status));
delete frcol;
delete uscol;
return;
}
{ // try override en_US collator
Collator *clone = frcol->clone();
URegistryKey key = Collator::registerInstance(frcol, US, status);
// frcol has been adopted. We must not use it any more, nor rely on its attributes.
frcol = NULL;
Collator* ncol = Collator::createInstance(US_FOO, status);
if (*clone != *ncol) {
errln("register of french collator for en_US failed on request for en_US_FOO");
}
delete clone;
// The requested locale may be the same as the valid locale,
// or may not be supported at all. See ticket #10477.
Locale loc = ncol->getLocale(ULOC_REQUESTED_LOCALE, status);
if (U_SUCCESS(status) && loc != US_FOO && loc != US) {
errln(UnicodeString("requested locale for en_US_FOO is not en_US_FOO nor en_US but ") + loc.getName());
}
status = U_ZERO_ERROR;
loc = ncol->getLocale(ULOC_VALID_LOCALE, status);
if (loc != US) {
errln(UnicodeString("valid locale for en_US_FOO is not en_US but ") + loc.getName());
}
loc = ncol->getLocale(ULOC_ACTUAL_LOCALE, status);
if (loc != US) {
errln(UnicodeString("actual locale for en_US_FOO is not en_US but ") + loc.getName());
}
delete ncol; ncol = NULL;
if (!Collator::unregister(key, status)) {
errln("failed to unregister french collator");
}
ncol = Collator::createInstance(US, status);
if (*uscol != *ncol) {
errln("collator after unregister does not match original");
}
delete ncol; ncol = NULL;
}
// recreate frcol
frcol = Collator::createInstance(FR, status);
LocalUCollatorPointer frFR(ucol_open("fr_FR", &status));
{ // try create collator for new locale
Locale fu_FU_FOO("fu", "FU", "FOO");
Locale fu_FU("fu", "FU", "");
Collator* fucol = Collator::createInstance(fu_FU, status);
Collator *clone = frcol->clone();
URegistryKey key = Collator::registerInstance(frcol, fu_FU, status);
frcol = NULL; // frcol has been adopted.
Collator* ncol = Collator::createInstance(fu_FU_FOO, status);
if (*clone != *ncol) {
errln("register of fr collator for fu_FU failed");
}
delete clone;
UnicodeString locName = fu_FU.getName();
StringEnumeration* localeEnum = Collator::getAvailableLocales();
UBool found = FALSE;
const UnicodeString* locStr, *ls2;
for (locStr = localeEnum->snext(status);
!found && locStr != NULL;
locStr = localeEnum->snext(status)) {
//
if (locName == *locStr) {
found = TRUE;
}
}
StringEnumeration *le2 = NULL;
localeEnum->reset(status);
int32_t i, count;
count = localeEnum->count(status);
for(i = 0; i < count; ++i) {
if(i == count / 2) {
le2 = localeEnum->clone();
if(le2 == NULL || count != le2->count(status)) {
errln("ServiceEnumeration.clone() failed");
break;
}
}
if(i >= count / 2) {
locStr = localeEnum->snext(status);
ls2 = le2->snext(status);
if(*locStr != *ls2) {
errln("ServiceEnumeration.clone() failed for item %d", i);
}
} else {
localeEnum->snext(status);
}
}
delete localeEnum;
delete le2;
if (!found) {
errln("new locale fu_FU not reported as supported locale");
}
UnicodeString displayName;
Collator::getDisplayName(fu_FU, displayName);
/* The locale display pattern for the locale ja, ko, and zh are different. */
const UChar zh_fuFU_Array[] = { 0x0066, 0x0075, 0xff08, 0x0046, 0x0055, 0xff09, 0 };
const UnicodeString zh_fuFU(zh_fuFU_Array);
const Locale& defaultLocale = Locale::getDefault();
if (displayName != "fu (FU)" &&
((defaultLocale == Locale::getKorean() && defaultLocale == Locale::getJapanese()) && displayName == "fu(FU)") &&
((defaultLocale == Locale::getChinese()) && displayName != zh_fuFU)) {
errln(UnicodeString("found ") + displayName + " for fu_FU");
}
Collator::getDisplayName(fu_FU, fu_FU, displayName);
if (displayName != "fu (FU)" &&
((defaultLocale == Locale::getKorean() && defaultLocale == Locale::getJapanese()) && displayName == "fu(FU)") &&
((defaultLocale == Locale::getChinese()) && displayName != zh_fuFU)) {
errln(UnicodeString("found ") + displayName + " for fu_FU");
}
// test ucol_open
LocalUCollatorPointer fufu(ucol_open("fu_FU_FOO", &status));
if (fufu.isNull()) {
errln("could not open fu_FU_FOO with ucol_open");
} else {
if (*Collator::fromUCollator(fufu.getAlias()) !=
*Collator::fromUCollator(frFR.getAlias())) {
errln("collator fufu != collator frFR");
}
}
if (!Collator::unregister(key, status)) {
errln("failed to unregister french collator");
}
// !!! note frcoll invalid again, but we're no longer using it
// other collators should still work ok
Locale nloc = ncol->getLocale(ULOC_VALID_LOCALE, status);
if (nloc != fu_FU) {
errln(UnicodeString("asked for nloc valid locale after close and got") + nloc.getName());
}
delete ncol; ncol = NULL;
if (fufu.isValid()) {
const char* nlocstr = ucol_getLocaleByType(fufu.getAlias(), ULOC_VALID_LOCALE, &status);
if (uprv_strcmp(nlocstr, "fu_FU") != 0) {
errln(UnicodeString("asked for uloc valid locale after close and got ") + nlocstr);
}
}
ncol = Collator::createInstance(fu_FU, status);
if (*fucol != *ncol) {
errln("collator after unregister does not match original fu_FU");
}
delete uscol; uscol = NULL;
delete ncol; ncol = NULL;
delete fucol; fucol = NULL;
}
#endif
}
/**
* This test does round-trip testing (format -> parse -> format -> parse -> etc.) of
* NumberFormat.
*/
void IntlTestNumberFormatAPI::testAPI(/* char* par */)
{
UErrorCode status = U_ZERO_ERROR;
// ======= Test constructors
logln("Testing NumberFormat constructors");
NumberFormat *def = NumberFormat::createInstance(status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create NumberFormat (default) - %s", u_errorName(status));
}
status = U_ZERO_ERROR;
NumberFormat *fr = NumberFormat::createInstance(Locale::getFrench(), status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create NumberFormat (French) - %s", u_errorName(status));
}
NumberFormat *cur = NumberFormat::createCurrencyInstance(status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create NumberFormat (currency, default) - %s", u_errorName(status));
}
status = U_ZERO_ERROR;
NumberFormat *cur_fr = NumberFormat::createCurrencyInstance(Locale::getFrench(), status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create NumberFormat (currency, French) - %s", u_errorName(status));
}
NumberFormat *per = NumberFormat::createPercentInstance(status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create NumberFormat (percent, default) - %s", u_errorName(status));
}
status = U_ZERO_ERROR;
NumberFormat *per_fr = NumberFormat::createPercentInstance(Locale::getFrench(), status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create NumberFormat (percent, French) - %s", u_errorName(status));
}
// ======= Test equality
if (per_fr != NULL && cur_fr != NULL)
{
logln("Testing equality operator");
if( *per_fr == *cur_fr || ! ( *per_fr != *cur_fr) ) {
errln("ERROR: == failed");
}
}
// ======= Test various format() methods
if (cur_fr != NULL)
{
logln("Testing various format() methods");
double d = -10456.0037;
int32_t l = 100000000;
Formattable fD(d);
Formattable fL(l);
UnicodeString res1, res2, res3, res4, res5, res6;
FieldPosition pos1(0), pos2(0), pos3(0), pos4(0);
res1 = cur_fr->format(d, res1);
logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res1);
res2 = cur_fr->format(l, res2);
logln((UnicodeString) "" + (int32_t) l + " formatted to " + res2);
res3 = cur_fr->format(d, res3, pos1);
logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res3);
res4 = cur_fr->format(l, res4, pos2);
logln((UnicodeString) "" + (int32_t) l + " formatted to " + res4);
status = U_ZERO_ERROR;
res5 = cur_fr->format(fD, res5, pos3, status);
if(U_FAILURE(status)) {
errln("ERROR: format(Formattable [double]) failed");
}
logln((UnicodeString) "" + (int32_t) fD.getDouble() + " formatted to " + res5);
status = U_ZERO_ERROR;
res6 = cur_fr->format(fL, res6, pos4, status);
if(U_FAILURE(status)) {
errln("ERROR: format(Formattable [long]) failed");
}
logln((UnicodeString) "" + fL.getLong() + " formatted to " + res6);
}
// ======= Test parse()
if (fr != NULL)
{
logln("Testing parse()");
double d = -10456.0037;
UnicodeString text("-10,456.0037");
Formattable result1, result2, result3;
ParsePosition pos(0), pos01(0);
fr->parseObject(text, result1, pos);
if(result1.getType() != Formattable::kDouble && result1.getDouble() != d) {
errln("ERROR: Roundtrip failed (via parse()) for " + text);
}
logln(text + " parsed into " + (int32_t) result1.getDouble());
fr->parse(text, result2, pos01);
if(result2.getType() != Formattable::kDouble && result2.getDouble() != d) {
errln("ERROR: Roundtrip failed (via parse()) for " + text);
}
logln(text + " parsed into " + (int32_t) result2.getDouble());
status = U_ZERO_ERROR;
fr->parse(text, result3, status);
if(U_FAILURE(status)) {
errln("ERROR: parse() failed");
}
if(result3.getType() != Formattable::kDouble && result3.getDouble() != d) {
errln("ERROR: Roundtrip failed (via parse()) for " + text);
}
logln(text + " parsed into " + (int32_t) result3.getDouble());
}
// ======= Test getters and setters
if (fr != NULL && def != NULL)
{
logln("Testing getters and setters");
int32_t count = 0;
const Locale *locales = NumberFormat::getAvailableLocales(count);
logln((UnicodeString) "Got " + count + " locales" );
for(int32_t i = 0; i < count; i++) {
UnicodeString name(locales[i].getName(),"");
logln(name);
}
fr->setParseIntegerOnly( def->isParseIntegerOnly() );
if(fr->isParseIntegerOnly() != def->isParseIntegerOnly() ) {
errln("ERROR: setParseIntegerOnly() failed");
}
fr->setGroupingUsed( def->isGroupingUsed() );
if(fr->isGroupingUsed() != def->isGroupingUsed() ) {
errln("ERROR: setGroupingUsed() failed");
}
fr->setMaximumIntegerDigits( def->getMaximumIntegerDigits() );
if(fr->getMaximumIntegerDigits() != def->getMaximumIntegerDigits() ) {
errln("ERROR: setMaximumIntegerDigits() failed");
}
fr->setMinimumIntegerDigits( def->getMinimumIntegerDigits() );
if(fr->getMinimumIntegerDigits() != def->getMinimumIntegerDigits() ) {
errln("ERROR: setMinimumIntegerDigits() failed");
}
fr->setMaximumFractionDigits( def->getMaximumFractionDigits() );
if(fr->getMaximumFractionDigits() != def->getMaximumFractionDigits() ) {
errln("ERROR: setMaximumFractionDigits() failed");
}
fr->setMinimumFractionDigits( def->getMinimumFractionDigits() );
if(fr->getMinimumFractionDigits() != def->getMinimumFractionDigits() ) {
errln("ERROR: setMinimumFractionDigits() failed");
}
}
// ======= Test getStaticClassID()
logln("Testing getStaticClassID()");
status = U_ZERO_ERROR;
NumberFormat *test = new DecimalFormat(status);
if(U_FAILURE(status)) {
errcheckln(status, "ERROR: Couldn't create a NumberFormat - %s", u_errorName(status));
}
if(test->getDynamicClassID() != DecimalFormat::getStaticClassID()) {
errln("ERROR: getDynamicClassID() didn't return the expected value");
}
delete test;
delete def;
delete fr;
delete cur;
delete cur_fr;
delete per;
delete per_fr;
}
// Use LocalXyzPointer types that are not covered elsewhere in the intltest suite.
void LocalPointerTest::TestLocalXyzPointer() {
IcuTestErrorCode errorCode(*this, "TestLocalXyzPointer");
static const char *const encoding="ISO-8859-1";
LocalUConverterSelectorPointer sel(
ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
if(errorCode.logIfFailureAndReset("ucnvsel_open()")) {
return;
}
if(sel.isNull()) {
errln("LocalUConverterSelectorPointer failure");
return;
}
#if !UCONFIG_NO_FORMATTING
LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
if(errorCode.logDataIfFailureAndReset("ucal_open()")) {
return;
}
if(cal.isNull()) {
errln("LocalUCalendarPointer failure");
return;
}
LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
if(errorCode.logIfFailureAndReset("udatpg_open()")) {
return;
}
if(patgen.isNull()) {
errln("LocalUDateTimePatternGeneratorPointer failure");
return;
}
LocalULocaleDisplayNamesPointer ldn(uldn_open("de-CH", ULDN_STANDARD_NAMES, errorCode));
if(errorCode.logIfFailureAndReset("uldn_open()")) {
return;
}
if(ldn.isNull()) {
errln("LocalULocaleDisplayNamesPointer failure");
return;
}
UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
LocalUMessageFormatPointer msg(
umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
if(errorCode.logIfFailureAndReset("umsg_open()")) {
return;
}
if(msg.isNull()) {
errln("LocalUMessageFormatPointer failure");
return;
}
#endif /* UCONFIG_NO_FORMATTING */
#if !UCONFIG_NO_NORMALIZATION
const UNormalizer2 *nfc=unorm2_getInstance(NULL, "nfc", UNORM2_COMPOSE, errorCode);
UnicodeSet emptySet;
LocalUNormalizer2Pointer fn2(unorm2_openFiltered(nfc, emptySet.toUSet(), errorCode));
if(errorCode.logIfFailureAndReset("unorm2_openFiltered()")) {
return;
}
if(fn2.isNull()) {
errln("LocalUNormalizer2Pointer failure");
return;
}
#endif /* !UCONFIG_NO_NORMALIZATION */
#if !UCONFIG_NO_REGULAR_EXPRESSIONS
UnicodeString pattern=UNICODE_STRING_SIMPLE("abc|xy+z");
LocalURegularExpressionPointer regex(
uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
if(errorCode.logIfFailureAndReset("uregex_open()")) {
return;
}
if(regex.isNull()) {
errln("LocalURegularExpressionPointer failure");
return;
}
#endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */
#if !UCONFIG_NO_TRANSLITERATION
UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
LocalUTransliteratorPointer trans(
utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
if(errorCode.logIfFailureAndReset("utrans_open()")) {
return;
}
if(trans.isNull()) {
errln("LocalUTransliteratorPointer failure");
return;
}
#endif /* !UCONFIG_NO_TRANSLITERATION */
// destructors
}
void DataDrivenCalendarTest::testConvert(int32_t n,
const CalendarFieldsSet &fromSet, Calendar *fromCalendar,
const CalendarFieldsSet &toSet, Calendar *toCalendar, UBool forward) {
UErrorCode status = U_ZERO_ERROR;
UnicodeString thisString = (UnicodeString)"#"+n+" "+(forward ? "forward"
: "reverse")+" "+fromCalendar->getType()+"->"+toCalendar->getType();
fromCalendar->clear();
fromSet.setOnCalendar(fromCalendar, status);
if (U_FAILURE(status)) {
errln("FAIL: Failed to set on Source calendar: %s", u_errorName(status));
return;
}
CalendarFieldsSet diffSet;
diffSet.clear();
// Is the calendar sane at the first?
if (!fromSet.matches(fromCalendar, diffSet, status)) {
UnicodeString diffs = diffSet.diffFrom(fromSet, status);
errln((UnicodeString)"FAIL: "+thisString
+", SOURCE calendar was not set: Differences: "+ diffs
+"', status: "+ u_errorName(status));
} else if (U_FAILURE(status)) {
errln("FAIL: "+thisString+" SOURCE calendar Failed to match: "
+u_errorName(status));
} else {
logln("PASS: "******" SOURCE calendar match.");
}
//logln("Set Source calendar: " + from);
UDate fromTime = fromCalendar->getTime(status);
if (U_FAILURE(status)) {
errln("FAIL: Failed to get Source time: %s", u_errorName(status));
return;
}
diffSet.clear();
// Is the calendar sane after being set?
if (!fromSet.matches(fromCalendar, diffSet, status)) {
UnicodeString diffs = diffSet.diffFrom(fromSet, status);
errln((UnicodeString)"FAIL: "+thisString
+", SET SOURCE calendar was not set: Differences: "+ diffs
+"', status: "+ u_errorName(status));
} else if (U_FAILURE(status)) {
errln("FAIL: "+thisString+" SET SOURCE calendar Failed to match: "
+u_errorName(status));
} else {
logln("PASS: "******" SET SOURCE calendar match.");
}
toCalendar->clear();
toCalendar->setTime(fromTime, status);
if (U_FAILURE(status)) {
errln("FAIL: Failed to set Target time: %s", u_errorName(status));
return;
}
diffSet.clear();
if (!toSet.matches(toCalendar, diffSet, status)) {
UnicodeString diffs = diffSet.diffFrom(toSet, status);
errln((UnicodeString)"FAIL: "+thisString+", Differences: "+ diffs
+"', status: "+ u_errorName(status));
SimpleDateFormat fmt(UnicodeString("EEE MMM dd yyyy G"), status);
UnicodeString fromString;
fmt.format(fromTime, fromString);
logln("Source Time: "+fromString+", Source Calendar: "
+fromCalendar->getType());
} else if (U_FAILURE(status)) {
errln("FAIL: "+thisString+" Failed to match: "+u_errorName(status));
} else {
logln("PASS: "******" match.");
}
}
void DataDrivenCalendarTest::testConvert(TestData *testData,
const DataMap *settings, UBool forward) {
UErrorCode status = U_ZERO_ERROR;
Calendar *toCalendar= NULL;
const DataMap *currentCase= NULL;
char toCalLoc[256] = "";
char fromCalLoc[256] = "";
// build to calendar
UnicodeString testSetting = settings->getString("ToCalendar", status);
if (U_SUCCESS(status)) {
testSetting.extract(0, testSetting.length(), toCalLoc, (const char*)0);
toCalendar = Calendar::createInstance(toCalLoc, status);
if (U_FAILURE(status)) {
dataerrln(UnicodeString("Unable to instantiate ToCalendar for ")+testSetting);
return;
}
}
CalendarFieldsSet fromSet, toSet, diffSet;
SimpleDateFormat fmt(UnicodeString("EEE MMM dd yyyy / YYYY'-W'ww-ee"),
status);
if (U_FAILURE(status)) {
errcheckln(status, "FAIL: Couldn't create SimpleDateFormat: %s",
u_errorName(status));
return;
}
// Start the processing
int n = 0;
while (testData->nextCase(currentCase, status)) {
++n;
Calendar *fromCalendar= NULL;
UnicodeString locale = currentCase->getString("locale", status);
if (U_SUCCESS(status)) {
locale.extract(0, locale.length(), fromCalLoc, (const char*)0); // default codepage. Invariant codepage doesn't have '@'!
fromCalendar = Calendar::createInstance(fromCalLoc, status);
if (U_FAILURE(status)) {
errln("Unable to instantiate fromCalendar for "+locale);
return;
}
} else {
errln("No 'locale' line.");
continue;
}
fromSet.clear();
toSet.clear();
UnicodeString from = currentCase->getString("from", status);
if (U_FAILURE(status)) {
errln("No 'from' line.");
continue;
}
fromSet.parseFrom(from, status);
if (U_FAILURE(status)) {
errln("Failed to parse 'from' parameter: "+from);
continue;
}
UnicodeString to = currentCase->getString("to", status);
if (U_FAILURE(status)) {
errln("No 'to' line.");
continue;
}
toSet.parseFrom(to, &fromSet, status);
if (U_FAILURE(status)) {
errln("Failed to parse 'to' parameter: "+to);
continue;
}
// now, do it.
if (forward) {
logln((UnicodeString)"#"+n+" "+locale+"/"+from+" >>> "+toCalLoc+"/"
+to);
testConvert(n, fromSet, fromCalendar, toSet, toCalendar, forward);
} else {
logln((UnicodeString)"#"+n+" "+locale+"/"+from+" <<< "+toCalLoc+"/"
+to);
testConvert(n, toSet, toCalendar, fromSet, fromCalendar, forward);
}
delete fromCalendar;
}
delete toCalendar;
}
void DecimalFormatTest::execFormatTest(int32_t lineNum,
const UnicodeString &pattern, // Pattern
const UnicodeString &round, // rounding mode
const UnicodeString &input, // input decimal number
const UnicodeString &expected, // expected formatted result
UErrorCode &status) {
if (U_FAILURE(status)) {
return;
}
DecimalFormatSymbols symbols(Locale::getUS(), status);
// printf("Pattern = %s\n", UnicodeStringPiece(pattern).data());
DecimalFormat fmtr(pattern, symbols, status);
if (U_FAILURE(status)) {
dataerrln("file dcfmtest.txt, line %d: %s error creating the formatter.",
lineNum, u_errorName(status));
return;
}
if (round=="ceiling") {
fmtr.setRoundingMode(DecimalFormat::kRoundCeiling);
} else if (round=="floor") {
fmtr.setRoundingMode(DecimalFormat::kRoundFloor);
} else if (round=="down") {
fmtr.setRoundingMode(DecimalFormat::kRoundDown);
} else if (round=="up") {
fmtr.setRoundingMode(DecimalFormat::kRoundUp);
} else if (round=="halfeven") {
fmtr.setRoundingMode(DecimalFormat::kRoundHalfEven);
} else if (round=="halfdown") {
fmtr.setRoundingMode(DecimalFormat::kRoundHalfDown);
} else if (round=="halfup") {
fmtr.setRoundingMode(DecimalFormat::kRoundHalfUp);
} else if (round=="default") {
// don't set any value.
} else if (round=="unnecessary") {
fmtr.setRoundingMode(DecimalFormat::kRoundUnnecessary);
} else {
fmtr.setRoundingMode(DecimalFormat::kRoundFloor);
errln("file dcfmtest.txt, line %d: Bad rounding mode \"%s\"",
lineNum, UnicodeStringPiece(round).data());
}
UnicodeString result;
UnicodeStringPiece spInput(input);
//fmtr.format(spInput, result, NULL, status);
Formattable fmtbl;
fmtbl.setDecimalNumber(spInput, status);
//NumberFormat &nfmtr = fmtr;
fmtr.format(fmtbl, result, NULL, status);
if ((status == U_FORMAT_INEXACT_ERROR) && (result == "") && (expected == "Inexact")) {
// Test succeeded.
status = U_ZERO_ERROR;
return;
}
if (U_FAILURE(status)) {
errln("file dcfmtest.txt, line %d: format() returned %s.",
lineNum, u_errorName(status));
status = U_ZERO_ERROR;
return;
}
if (result != expected) {
errln("file dcfmtest.txt, line %d: expected \"%s\", got \"%s\"",
lineNum, UnicodeStringPiece(expected).data(), UnicodeStringPiece(result).data());
}
}
//-------------------------------------------------------------------------------
//
// Read a text data file, convert it from UTF-8 to UChars, and return the data
// in one big UChar * buffer, which the caller must delete.
//
// (Lightly modified version of a similar function in regextst.cpp)
//
//--------------------------------------------------------------------------------
UChar *DecimalFormatTest::ReadAndConvertFile(const char *fileName, int32_t &ulen,
UErrorCode &status) {
UChar *retPtr = NULL;
char *fileBuf = NULL;
const char *fileBufNoBOM = NULL;
FILE *f = NULL;
ulen = 0;
if (U_FAILURE(status)) {
return retPtr;
}
//
// Open the file.
//
f = fopen(fileName, "rb");
if (f == 0) {
dataerrln("Error opening test data file %s\n", fileName);
status = U_FILE_ACCESS_ERROR;
return NULL;
}
//
// Read it in
//
int32_t fileSize;
int32_t amtRead;
int32_t amtReadNoBOM;
fseek( f, 0, SEEK_END);
fileSize = ftell(f);
fileBuf = new char[fileSize];
fseek(f, 0, SEEK_SET);
amtRead = fread(fileBuf, 1, fileSize, f);
if (amtRead != fileSize || fileSize <= 0) {
errln("Error reading test data file.");
goto cleanUpAndReturn;
}
//
// Look for a UTF-8 BOM on the data just read.
// The test data file is UTF-8.
// The BOM needs to be there in the source file to keep the Windows &
// EBCDIC machines happy, so force an error if it goes missing.
// Many Linux editors will silently strip it.
//
fileBufNoBOM = fileBuf + 3;
amtReadNoBOM = amtRead - 3;
if (fileSize<3 || uprv_strncmp(fileBuf, "\xEF\xBB\xBF", 3) != 0) {
// TODO: restore this check.
errln("Test data file %s is missing its BOM", fileName);
fileBufNoBOM = fileBuf;
amtReadNoBOM = amtRead;
}
//
// Find the length of the input in UTF-16 UChars
// (by preflighting the conversion)
//
u_strFromUTF8(NULL, 0, &ulen, fileBufNoBOM, amtReadNoBOM, &status);
//
// Convert file contents from UTF-8 to UTF-16
//
if (status == U_BUFFER_OVERFLOW_ERROR) {
// Buffer Overflow is expected from the preflight operation.
status = U_ZERO_ERROR;
retPtr = new UChar[ulen+1];
u_strFromUTF8(retPtr, ulen+1, NULL, fileBufNoBOM, amtReadNoBOM, &status);
}
cleanUpAndReturn:
fclose(f);
delete[] fileBuf;
if (U_FAILURE(status)) {
errln("ICU Error \"%s\"\n", u_errorName(status));
delete retPtr;
retPtr = NULL;
};
return retPtr;
}
void DecimalFormatTest::execParseTest(int32_t lineNum,
const UnicodeString &inputText,
const UnicodeString &expectedType,
const UnicodeString &expectedDecimal,
UErrorCode &status) {
if (U_FAILURE(status)) {
return;
}
DecimalFormatSymbols symbols(Locale::getUS(), status);
UnicodeString pattern = UNICODE_STRING_SIMPLE("####");
DecimalFormat format(pattern, symbols, status);
Formattable result;
if (U_FAILURE(status)) {
dataerrln("file dcfmtest.txt, line %d: %s error creating the formatter.",
lineNum, u_errorName(status));
return;
}
ParsePosition pos;
int32_t expectedParseEndPosition = inputText.length();
format.parse(inputText, result, pos);
if (expectedParseEndPosition != pos.getIndex()) {
errln("file dcfmtest.txt, line %d: Expected parse position afeter parsing: %d. "
"Actual parse position: %d", expectedParseEndPosition, pos.getIndex());
return;
}
char expectedTypeC[2];
expectedType.extract(0, 1, expectedTypeC, 2, US_INV);
Formattable::Type expectType = Formattable::kDate;
switch (expectedTypeC[0]) {
case 'd': expectType = Formattable::kDouble; break;
case 'i': expectType = Formattable::kLong; break;
case 'l': expectType = Formattable::kInt64; break;
default:
errln("file dcfmtest.tx, line %d: unrecongized expected type \"%s\"",
lineNum, InvariantStringPiece(expectedType).data());
return;
}
if (result.getType() != expectType) {
errln("file dcfmtest.txt, line %d: expectedParseType(%s) != actual parseType(%s)",
lineNum, formattableType(expectType), formattableType(result.getType()));
return;
}
StringPiece decimalResult = result.getDecimalNumber(status);
if (U_FAILURE(status)) {
errln("File %s, line %d: error %s. Line in file dcfmtest.txt: %d:",
__FILE__, __LINE__, u_errorName(status), lineNum);
return;
}
InvariantStringPiece expectedResults(expectedDecimal);
if (decimalResult != expectedResults) {
errln("file dcfmtest.txt, line %d: expected \"%s\", got \"%s\"",
lineNum, expectedResults.data(), decimalResult.data());
}
return;
}
void DecimalFormatTest::DataDrivenTests() {
char tdd[2048];
const char *srcPath;
UErrorCode status = U_ZERO_ERROR;
int32_t lineNum = 0;
//
// Open and read the test data file.
//
srcPath=getPath(tdd, "dcfmtest.txt");
if(srcPath==NULL) {
return; /* something went wrong, error already output */
}
int32_t len;
UChar *testData = ReadAndConvertFile(srcPath, len, status);
if (U_FAILURE(status)) {
return; /* something went wrong, error already output */
}
//
// Put the test data into a UnicodeString
//
UnicodeString testString(FALSE, testData, len);
RegexMatcher parseLineMat(UnicodeString(
"(?i)\\s*parse\\s+"
"\"([^\"]*)\"\\s+" // Capture group 1: input text
"([ild])\\s+" // Capture group 2: expected parsed type
"\"([^\"]*)\"\\s+" // Capture group 3: expected parsed decimal
"\\s*(?:#.*)?"), // Trailing comment
0, status);
RegexMatcher formatLineMat(UnicodeString(
"(?i)\\s*format\\s+"
"(\\S+)\\s+" // Capture group 1: pattern
"(ceiling|floor|down|up|halfeven|halfdown|halfup|default|unnecessary)\\s+" // Capture group 2: Rounding Mode
"\"([^\"]*)\"\\s+" // Capture group 3: input
"\"([^\"]*)\"" // Capture group 4: expected output
"\\s*(?:#.*)?"), // Trailing comment
0, status);
RegexMatcher commentMat (UNICODE_STRING_SIMPLE("\\s*(#.*)?$"), 0, status);
RegexMatcher lineMat(UNICODE_STRING_SIMPLE("(?m)^(.*?)$"), testString, 0, status);
if (U_FAILURE(status)){
dataerrln("Construct RegexMatcher() error.");
delete [] testData;
return;
}
//
// Loop over the test data file, once per line.
//
while (lineMat.find()) {
lineNum++;
if (U_FAILURE(status)) {
dataerrln("File dcfmtest.txt, line %d: ICU Error \"%s\"", lineNum, u_errorName(status));
}
status = U_ZERO_ERROR;
UnicodeString testLine = lineMat.group(1, status);
// printf("%s\n", UnicodeStringPiece(testLine).data());
if (testLine.length() == 0) {
continue;
}
//
// Parse the test line. Skip blank and comment only lines.
// Separate out the three main fields - pattern, flags, target.
//
commentMat.reset(testLine);
if (commentMat.lookingAt(status)) {
// This line is a comment, or blank.
continue;
}
//
// Handle "parse" test case line from file
//
parseLineMat.reset(testLine);
if (parseLineMat.lookingAt(status)) {
execParseTest(lineNum,
parseLineMat.group(1, status), // input
parseLineMat.group(2, status), // Expected Type
parseLineMat.group(3, status), // Expected Decimal String
status
);
continue;
}
//
// Handle "format" test case line
//
formatLineMat.reset(testLine);
if (formatLineMat.lookingAt(status)) {
execFormatTest(lineNum,
formatLineMat.group(1, status), // Pattern
formatLineMat.group(2, status), // rounding mode
formatLineMat.group(3, status), // input decimal number
formatLineMat.group(4, status), // expected formatted result
status);
continue;
}
//
// Line is not a recognizable test case.
//
errln("Badly formed test case at line %d.\n%s\n",
lineNum, UnicodeStringPiece(testLine).data());
}
delete [] testData;
}
void UCAConformanceTest::testConformance(const Collator *coll)
{
if(testFile == 0) {
return;
}
uint32_t skipFlags = 0;
if(coll->getAttribute(UCOL_ALTERNATE_HANDLING, status) == UCOL_SHIFTED) {
skipFlags |= IS_SHIFTED;
}
if(coll == rbUCA) {
skipFlags |= FROM_RULES;
}
logln("-prop:ucaconfnosortkeys=1 turns off getSortKey() in UCAConformanceTest");
UBool withSortKeys = getProperty("ucaconfnosortkeys") == NULL;
int32_t line = 0;
UChar b1[1024], b2[1024];
UChar *buffer = b1, *oldB = NULL;
char lineB1[1024], lineB2[1024];
char *lineB = lineB1, *oldLineB = lineB2;
uint8_t sk1[1024], sk2[1024];
uint8_t *oldSk = NULL, *newSk = sk1;
int32_t oldLen = 0;
int32_t oldBlen = 0;
uint32_t first = 0;
while (fgets(lineB, 1024, testFile) != NULL) {
// remove trailing whitespace
u_rtrim(lineB);
line++;
if(*lineB == 0 || lineB[0] == '#') {
continue;
}
int32_t buflen = u_parseString(lineB, buffer, 1024, &first, &status);
if(U_FAILURE(status)) {
errln("Error parsing line %ld (%s): %s\n",
(long)line, u_errorName(status), lineB);
status = U_ZERO_ERROR;
}
buffer[buflen] = 0;
if(skipLineBecauseOfBug(buffer, buflen, skipFlags)) {
logln("Skipping line %i because of a known bug", line);
continue;
}
int32_t resLen = withSortKeys ? coll->getSortKey(buffer, buflen, newSk, 1024) : 0;
if(oldSk != NULL) {
UBool ok=TRUE;
int32_t skres = withSortKeys ? strcmp((char *)oldSk, (char *)newSk) : 0;
int32_t cmpres = coll->compare(oldB, oldBlen, buffer, buflen, status);
int32_t cmpres2 = coll->compare(buffer, buflen, oldB, oldBlen, status);
if(cmpres != -cmpres2) {
errln("Compare result not symmetrical on line %i: "
"previous vs. current (%d) / current vs. previous (%d)",
line, cmpres, cmpres2);
ok = FALSE;
}
// TODO: Compare with normalization turned off if the input passes the FCD test.
if(withSortKeys && cmpres != normalizeResult(skres)) {
errln("Difference between coll->compare (%d) and sortkey compare (%d) on line %i",
cmpres, skres, line);
ok = FALSE;
}
int32_t res = cmpres;
if(res == 0 && !isAtLeastUCA62) {
// Up to UCA 6.1, the collation test files use a custom tie-breaker,
// comparing the raw input strings.
res = u_strcmpCodePointOrder(oldB, buffer);
// Starting with UCA 6.2, the collation test files use the standard UCA tie-breaker,
// comparing the NFD versions of the input strings,
// which we do via setting strength=identical.
}
if(res > 0) {
errln("Line %i is not greater or equal than previous line", line);
ok = FALSE;
}
if(!ok) {
errln(" Previous data line %s", oldLineB);
errln(" Current data line %s", lineB);
if(withSortKeys) {
UnicodeString oldS, newS;
prettify(CollationKey(oldSk, oldLen), oldS);
prettify(CollationKey(newSk, resLen), newS);
errln(" Previous key: "+oldS);
errln(" Current key: "+newS);
}
}
}
// swap buffers
oldLineB = lineB;
oldB = buffer;
oldSk = newSk;
if(lineB == lineB1) {
lineB = lineB2;
buffer = b2;
newSk = sk2;
} else {
lineB = lineB1;
buffer = b1;
newSk = sk1;
}
oldLen = resLen;
oldBlen = buflen;
}
}
void DataDrivenFormatTest::testConvertDate(TestData *testData,
const DataMap * /* settings */, UBool fmt) {
UnicodeString kPATTERN("PATTERN="); // TODO: static
UnicodeString kMILLIS("MILLIS="); // TODO: static
UnicodeString kRELATIVE_MILLIS("RELATIVE_MILLIS="); // TODO: static
UnicodeString kRELATIVE_ADD("RELATIVE_ADD:"); // TODO: static
UErrorCode status = U_ZERO_ERROR;
SimpleDateFormat basicFmt(UnicodeString("EEE MMM dd yyyy / YYYY'-W'ww-ee"),
status);
if (U_FAILURE(status)) {
dataerrln("FAIL: Couldn't create basic SimpleDateFormat: %s",
u_errorName(status));
return;
}
const DataMap *currentCase= NULL;
// Start the processing
int n = 0;
while (testData->nextCase(currentCase, status)) {
char calLoc[256] = "";
DateTimeStyleSet styleSet;
UnicodeString pattern;
UBool usePattern = FALSE;
(void)usePattern; // Suppress unused warning.
CalendarFieldsSet fromSet;
UDate fromDate = 0;
UBool useDate = FALSE;
UDate now = Calendar::getNow();
++n;
char theCase[200];
sprintf(theCase, "case %d:", n);
UnicodeString caseString(theCase, "");
// load params
UnicodeString locale = currentCase->getString("locale", status);
if (U_FAILURE(status)) {
errln("case %d: No 'locale' line.", n);
continue;
}
UnicodeString zone = currentCase->getString("zone", status);
if (U_FAILURE(status)) {
errln("case %d: No 'zone' line.", n);
continue;
}
UnicodeString spec = currentCase->getString("spec", status);
if(U_FAILURE(status)) {
errln("case %d: No 'spec' line.", n);
continue;
}
UnicodeString date = currentCase->getString("date", status);
if(U_FAILURE(status)) {
errln("case %d: No 'date' line.", n);
continue;
}
UnicodeString expectStr= currentCase->getString("str", status);
if(U_FAILURE(status)) {
errln("case %d: No 'str' line.", n);
continue;
}
DateFormat *format = NULL;
// Process: 'locale'
locale.extract(0, locale.length(), calLoc, (const char*)0); // default codepage. Invariant codepage doesn't have '@'!
Locale loc(calLoc);
if(spec.startsWith(kPATTERN)) {
pattern = UnicodeString(spec,kPATTERN.length());
usePattern = TRUE;
format = new SimpleDateFormat(pattern, loc, status);
if(U_FAILURE(status)) {
errln("case %d: could not create SimpleDateFormat from pattern: %s", n, u_errorName(status));
continue;
}
} else {
if(styleSet.parseFrom(spec, status)<0 || U_FAILURE(status)) {
errln("case %d: could not parse spec as style fields: %s", n, u_errorName(status));
continue;
}
format = DateFormat::createDateTimeInstance((DateFormat::EStyle)styleSet.getDateStyle(), (DateFormat::EStyle)styleSet.getTimeStyle(), loc);
if(format == NULL ) {
errln("case %d: could not create SimpleDateFormat from styles.", n);
continue;
}
}
Calendar *cal = Calendar::createInstance(loc, status);
if(U_FAILURE(status)) {
errln("case %d: could not create calendar from %s", n, calLoc);
}
if (zone.length() > 0) {
TimeZone * tz = TimeZone::createTimeZone(zone);
cal->setTimeZone(*tz);
format->setTimeZone(*tz);
delete tz;
}
// parse 'date'
if(date.startsWith(kMILLIS)) {
UnicodeString millis = UnicodeString(date, kMILLIS.length());
useDate = TRUE;
fromDate = udbg_stod(millis);
} else if(date.startsWith(kRELATIVE_MILLIS)) {
UnicodeString millis = UnicodeString(date, kRELATIVE_MILLIS.length());
useDate = TRUE;
fromDate = udbg_stod(millis) + now;
} else if(date.startsWith(kRELATIVE_ADD)) {
UnicodeString add = UnicodeString(date, kRELATIVE_ADD.length()); // "add" is a string indicating which fields to add
if(fromSet.parseFrom(add, status)<0 || U_FAILURE(status)) {
errln("case %d: could not parse date as RELATIVE_ADD calendar fields: %s", n, u_errorName(status));
continue;
}
useDate=TRUE;
cal->clear();
cal->setTime(now, status);
for (int q=0; q<UCAL_FIELD_COUNT; q++) {
if (fromSet.isSet((UCalendarDateFields)q)) {
//int32_t oldv = cal->get((UCalendarDateFields)q, status);
if (q == UCAL_DATE) {
cal->add((UCalendarDateFields)q,
fromSet.get((UCalendarDateFields)q), status);
} else {
cal->set((UCalendarDateFields)q,
fromSet.get((UCalendarDateFields)q));
}
//int32_t newv = cal->get((UCalendarDateFields)q, status);
}
}
fromDate = cal->getTime(status);
if(U_FAILURE(status)) {
errln("case %d: could not apply date as RELATIVE_ADD calendar fields: %s", n, u_errorName(status));
continue;
}
} else if(fromSet.parseFrom(date, status)<0 || U_FAILURE(status)) {
errln("case %d: could not parse date as calendar fields: %s", n, u_errorName(status));
continue;
}
// now, do it.
if (fmt) {
FieldPosition pos;
// logln((UnicodeString)"#"+n+" "+locale+"/"+from+" >>> "+toCalLoc+"/"
// +to);
cal->clear();
UnicodeString output;
output.remove();
if(useDate) {
// cal->setTime(fromDate, status);
// if(U_FAILURE(status)) {
// errln("case %d: could not set time on calendar: %s", n, u_errorName(status));
// continue;
// }
format->format(fromDate, output, pos, status);
} else {
fromSet.setOnCalendar(cal, status);
if(U_FAILURE(status)) {
errln("case %d: could not set fields on calendar: %s", n, u_errorName(status));
continue;
}
format->format(*cal, output, pos);
}
// check erro result from 'format'
if(U_FAILURE(status)) {
errln("case %d: could not format(): %s", n, u_errorName(status)); // TODO: use 'pos'
}
// if(pos.getBeginIndex()==0 && pos.getEndIndex()==0) { // TODO: more precise error?
// errln("WARNING: case %d: format's pos returned (0,0) - error ??", n);
// }
if(output == expectStr) {
logln(caseString+": format: SUCCESS! "+UnicodeString("expect=output=")+output);
} else {
UnicodeString result;
UnicodeString result2;
errln(caseString+": format: output!=expectStr, got " + *udbg_escape(output, &result) + " expected " + *udbg_escape(expectStr, &result2));
}
} else {
cal->clear();
ParsePosition pos;
format->parse(expectStr,*cal,pos);
if(useDate) {
UDate gotDate = cal->getTime(status);
if(U_FAILURE(status)) {
errln(caseString+": parse: could not get time on calendar: "+UnicodeString(u_errorName(status)));
continue;
}
if(gotDate == fromDate) {
logln(caseString+": parse: SUCCESS! "+UnicodeString("gotDate=parseDate=")+expectStr);
} else {
UnicodeString expectDateStr, gotDateStr;
basicFmt.format(fromDate,expectDateStr);
basicFmt.format(gotDate,gotDateStr);
errln(caseString+": parse: FAIL. parsed '"+expectStr+"' and got "+gotDateStr+", expected " + expectDateStr);
}
} else {
// Calendar *cal2 = cal->clone();
// cal2->clear();
// fromSet.setOnCalendar(cal2, status);
if(U_FAILURE(status)) {
errln("case %d: parse: could not set fields on calendar: %s", n, u_errorName(status));
continue;
}
CalendarFieldsSet diffSet;
// diffSet.clear();
if (!fromSet.matches(cal, diffSet, status)) {
UnicodeString diffs = diffSet.diffFrom(fromSet, status);
errln((UnicodeString)"FAIL: "+caseString
+", Differences: '"+ diffs
+"', status: "+ u_errorName(status));
} else if (U_FAILURE(status)) {
errln("FAIL: "+caseString+" parse SET SOURCE calendar Failed to match: "
+u_errorName(status));
} else {
logln("PASS: "******" parse.");
}
}
}
delete cal;
delete format;
}
// delete basicFmt;
}
void DataDrivenCalendarTest::testOps(TestData *testData,
const DataMap * /*settings*/) {
UErrorCode status = U_ZERO_ERROR;
UBool useDate = FALSE; // TODO
UnicodeString kMILLIS("MILLIS="); // TODO: static
UDate fromDate = 0; // TODO
UDate toDate = 0;
const DataMap *currentCase= NULL;
char toCalLoc[256] = "";
// TODO: static strings?
const UnicodeString kADD("add", "");
const UnicodeString kROLL("roll", "");
// Get 'from' time
CalendarFieldsSet fromSet, toSet, paramsSet, diffSet;
SimpleDateFormat fmt(UnicodeString("EEE MMM dd yyyy / YYYY'-W'ww-ee"),
status);
if (U_FAILURE(status)) {
dataerrln("FAIL: Couldn't create SimpleDateFormat: %s",
u_errorName(status));
return;
}
// Start the processing
int n = 0;
while (testData->nextCase(currentCase, status)) {
++n;
Calendar *toCalendar= NULL;
Calendar *fromCalendar= NULL;
// load parameters
char theCase[200];
sprintf(theCase, "[case %d]", n);
UnicodeString caseString(theCase, "");
// build to calendar
// Headers { "locale","from","operation","params","to" }
// #1 locale
const char *param = "locale";
UnicodeString locale;
UnicodeString testSetting = currentCase->getString(param, status);
if (U_FAILURE(status)) {
errln(caseString+": Unable to get param '"+param+"' "
+ UnicodeString(" - "));
continue;
}
testSetting.extract(0, testSetting.length(), toCalLoc, (const char*)0);
fromCalendar = Calendar::createInstance(toCalLoc, status);
if (U_FAILURE(status)) {
errln(caseString+": Unable to instantiate calendar for "
+testSetting);
continue;
}
fromSet.clear();
// #2 'from' info
param = "from";
UnicodeString from = testSetting=currentCase->getString(param, status);
if (U_FAILURE(status)) {
errln(caseString+": Unable to get parameter '"+param+"' "
+ UnicodeString(" - "));
continue;
}
if(from.startsWith(kMILLIS)){
UnicodeString millis = UnicodeString(from, kMILLIS.length());
useDate = TRUE;
fromDate = udbg_stod(millis);
} else if(fromSet.parseFrom(testSetting, status)<0 || U_FAILURE(status)){
errln(caseString+": Failed to parse '"+param+"' parameter: "
+testSetting);
continue;
}
// #4 'operation' info
param = "operation";
UnicodeString operation = testSetting=currentCase->getString(param,
status);
if (U_FAILURE(status)) {
errln(caseString+": Unable to get parameter '"+param+"' "
+ UnicodeString(" - "));
continue;
}
if (U_FAILURE(status)) {
errln(caseString+": Failed to parse '"+param+"' parameter: "
+testSetting);
continue;
}
paramsSet.clear();
// #3 'params' info
param = "params";
UnicodeString params = testSetting
=currentCase->getString(param, status);
if (U_FAILURE(status)) {
errln(caseString+": Unable to get parameter '"+param+"' "
+ UnicodeString(" - "));
continue;
}
paramsSet.parseFrom(testSetting, status); // parse with inheritance.
if (U_FAILURE(status)) {
errln(caseString+": Failed to parse '"+param+"' parameter: "
+testSetting);
continue;
}
toSet.clear();
// #4 'to' info
param = "to";
UnicodeString to = testSetting=currentCase->getString(param, status);
if (U_FAILURE(status)) {
errln(caseString+": Unable to get parameter '"+param+"' "
+ UnicodeString(" - "));
continue;
}
if(to.startsWith(kMILLIS)){
UnicodeString millis = UnicodeString(to, kMILLIS.length());
useDate = TRUE;
toDate = udbg_stod(millis);
} else if(toSet.parseFrom(testSetting, &fromSet, status)<0 || U_FAILURE(status)){
errln(caseString+": Failed to parse '"+param+"' parameter: "
+testSetting);
continue;
}
UnicodeString caseContentsString = locale+": from "+from+": "
+operation +" [[[ "+params+" ]]] >>> "+to;
logln(caseString+": "+caseContentsString);
// ------
// now, do it.
/// prepare calendar
if(useDate){
fromCalendar->setTime(fromDate, status);
if (U_FAILURE(status)) {
errln(caseString+" FAIL: Failed to set time on Source calendar: "
+ u_errorName(status));
return;
}
} else {
fromSet.setOnCalendar(fromCalendar, status);
if (U_FAILURE(status)) {
errln(caseString+" FAIL: Failed to set on Source calendar: "
+ u_errorName(status));
return;
}
}
diffSet.clear();
// Is the calendar sane after being set?
if (!fromSet.matches(fromCalendar, diffSet, status)) {
UnicodeString diffs = diffSet.diffFrom(fromSet, status);
errln((UnicodeString)"FAIL: "+caseString
+", SET SOURCE calendar was not set: Differences: "+ diffs
+"', status: "+ u_errorName(status));
} else if (U_FAILURE(status)) {
errln("FAIL: "+caseString+" SET SOURCE calendar Failed to match: "
+u_errorName(status));
} else {
logln("PASS: "******" SET SOURCE calendar match.");
}
// to calendar - copy of from calendar
toCalendar = fromCalendar->clone();
/// perform op
for (int q=0; q<UCAL_FIELD_COUNT; q++) {
if (paramsSet.isSet((UCalendarDateFields)q)) {
if (operation == kROLL) {
toCalendar->roll((UCalendarDateFields)q,
paramsSet.get((UCalendarDateFields)q), status);
} else if (operation == kADD) {
toCalendar->add((UCalendarDateFields)q,
paramsSet.get((UCalendarDateFields)q), status);
} else {
errln(caseString+ " FAIL: unknown operation "+ operation);
}
logln(operation + " of "+ paramsSet.get((UCalendarDateFields)q)
+" -> "+u_errorName(status));
}
}
if (U_FAILURE(status)) {
errln(caseString+" FAIL: after "+operation+" of "+params+" -> "
+u_errorName(status));
continue;
}
// now - what's the result?
diffSet.clear();
if(useDate){
if(!(toCalendar->getTime(status)==toDate) || U_FAILURE(status)){
errln("FAIL: "+caseString+" Match operation had an error: "
+u_errorName(status));
}else{
logln(caseString + " SUCCESS: got=expected="+toDate);
logln("PASS: "******" matched!");
}
} else if (!toSet.matches(toCalendar, diffSet, status)) {
UnicodeString diffs = diffSet.diffFrom(toSet, status);
errln((UnicodeString)"FAIL: "+caseString+" - , "+caseContentsString
+" Differences: "+ diffs +"', status: "
+ u_errorName(status));
}else if (U_FAILURE(status)) {
errln("FAIL: "+caseString+" Match operation had an error: "
+u_errorName(status));
}else {
logln("PASS: "******" matched!");
}
delete fromCalendar;
delete toCalendar;
}
}
void
IntlTestNumberFormatAPI::testRegistration()
{
#if !UCONFIG_NO_SERVICE
UErrorCode status = U_ZERO_ERROR;
LocalPointer<NumberFormat> f0(NumberFormat::createInstance(SWAP_LOC, status));
LocalPointer<NumberFormat> f1(NumberFormat::createInstance(SRC_LOC, status));
LocalPointer<NumberFormat> f2(NumberFormat::createCurrencyInstance(SRC_LOC, status));
URegistryKey key = NumberFormat::registerFactory(new NFTestFactory(), status);
LocalPointer<NumberFormat> f3(NumberFormat::createCurrencyInstance(SRC_LOC, status));
LocalPointer<NumberFormat> f3a(NumberFormat::createCurrencyInstance(SRC_LOC, status));
LocalPointer<NumberFormat> f4(NumberFormat::createInstance(SRC_LOC, status));
StringEnumeration* locs = NumberFormat::getAvailableLocales();
LocalUNumberFormatPointer uf3(unum_open(UNUM_CURRENCY, NULL, 0, SRC_LOC.getName(), NULL, &status));
LocalUNumberFormatPointer uf4(unum_open(UNUM_DEFAULT, NULL, 0, SRC_LOC.getName(), NULL, &status));
const UnicodeString* res;
for (res = locs->snext(status); res; res = locs->snext(status)) {
logln(*res); // service is still in synch
}
NumberFormat::unregister(key, status); // restore for other tests
LocalPointer<NumberFormat> f5(NumberFormat::createCurrencyInstance(SRC_LOC, status));
LocalUNumberFormatPointer uf5(unum_open(UNUM_CURRENCY, NULL, 0, SRC_LOC.getName(), NULL, &status));
if (U_FAILURE(status)) {
dataerrln("Error creating instnaces.");
return;
} else {
float n = 1234.567f;
UnicodeString res0, res1, res2, res3, res4, res5;
UChar ures3[50];
UChar ures4[50];
UChar ures5[50];
f0->format(n, res0);
f1->format(n, res1);
f2->format(n, res2);
f3->format(n, res3);
f4->format(n, res4);
f5->format(n, res5);
unum_formatDouble(uf3.getAlias(), n, ures3, 50, NULL, &status);
unum_formatDouble(uf4.getAlias(), n, ures4, 50, NULL, &status);
unum_formatDouble(uf5.getAlias(), n, ures5, 50, NULL, &status);
logln((UnicodeString)"f0 swap int: " + res0);
logln((UnicodeString)"f1 src int: " + res1);
logln((UnicodeString)"f2 src cur: " + res2);
logln((UnicodeString)"f3 reg cur: " + res3);
logln((UnicodeString)"f4 reg int: " + res4);
logln((UnicodeString)"f5 unreg cur: " + res5);
log("uf3 reg cur: ");
logln(ures3);
log("uf4 reg int: ");
logln(ures4);
log("uf5 ureg cur: ");
logln(ures5);
if (f3.getAlias() == f3a.getAlias()) {
errln("did not get new instance from service");
f3a.orphan();
}
if (res3 != res0) {
errln("registered service did not match");
}
if (res4 != res1) {
errln("registered service did not inherit");
}
if (res5 != res2) {
errln("unregistered service did not match original");
}
if (res0 != ures3) {
errln("registered service did not match / unum");
}
if (res1 != ures4) {
errln("registered service did not inherit / unum");
}
if (res2 != ures5) {
errln("unregistered service did not match original / unum");
}
}
for (res = locs->snext(status); res; res = locs->snext(status)) {
errln(*res); // service should be out of synch
}
locs->reset(status); // now in synch again, we hope
for (res = locs->snext(status); res; res = locs->snext(status)) {
logln(*res);
}
delete locs;
#endif
}
UBool BiDiConformanceTest::parseInputStringFromBiDiClasses(const char *&start) {
inputString.remove();
/*
* Lengthy but fast BiDi class parser.
* A simple parser could terminate or extract the name string and use
* int32_t biDiClassInt=u_getPropertyValueEnum(UCHAR_BIDI_CLASS, bidiClassString);
* but that makes this test take significantly more time.
*/
while(*start!=0 && *(start=u_skipWhitespace(start))!=0 && *start!=';') {
UCharDirection biDiClass=U_CHAR_DIRECTION_COUNT;
// Compare each character once until we have a match on
// a complete, short BiDi class name.
if(start[0]=='L') {
if(start[1]=='R') {
if(start[2]=='E') {
biDiClass=U_LEFT_TO_RIGHT_EMBEDDING;
} else if(start[2]=='I') {
biDiClass=U_LEFT_TO_RIGHT_ISOLATE;
} else if(start[2]=='O') {
biDiClass=U_LEFT_TO_RIGHT_OVERRIDE;
}
} else {
biDiClass=U_LEFT_TO_RIGHT;
}
} else if(start[0]=='R') {
if(start[1]=='L') {
if(start[2]=='E') {
biDiClass=U_RIGHT_TO_LEFT_EMBEDDING;
} else if(start[2]=='I') {
biDiClass=U_RIGHT_TO_LEFT_ISOLATE;
} else if(start[2]=='O') {
biDiClass=U_RIGHT_TO_LEFT_OVERRIDE;
}
} else {
biDiClass=U_RIGHT_TO_LEFT;
}
} else if(start[0]=='E') {
if(start[1]=='N') {
biDiClass=U_EUROPEAN_NUMBER;
} else if(start[1]=='S') {
biDiClass=U_EUROPEAN_NUMBER_SEPARATOR;
} else if(start[1]=='T') {
biDiClass=U_EUROPEAN_NUMBER_TERMINATOR;
}
} else if(start[0]=='A') {
if(start[1]=='L') {
biDiClass=U_RIGHT_TO_LEFT_ARABIC;
} else if(start[1]=='N') {
biDiClass=U_ARABIC_NUMBER;
}
} else if(start[0]=='C' && start[1]=='S') {
biDiClass=U_COMMON_NUMBER_SEPARATOR;
} else if(start[0]=='B') {
if(start[1]=='N') {
biDiClass=U_BOUNDARY_NEUTRAL;
} else {
biDiClass=U_BLOCK_SEPARATOR;
}
} else if(start[0]=='S') {
biDiClass=U_SEGMENT_SEPARATOR;
} else if(start[0]=='W' && start[1]=='S') {
biDiClass=U_WHITE_SPACE_NEUTRAL;
} else if(start[0]=='O' && start[1]=='N') {
biDiClass=U_OTHER_NEUTRAL;
} else if(start[0]=='P' && start[1]=='D') {
if(start[2]=='F') {
biDiClass=U_POP_DIRECTIONAL_FORMAT;
} else if(start[2]=='I') {
biDiClass=U_POP_DIRECTIONAL_ISOLATE;
}
} else if(start[0]=='N' && start[1]=='S' && start[2]=='M') {
biDiClass=U_DIR_NON_SPACING_MARK;
} else if(start[0]=='F' && start[1]=='S' && start[2]=='I') {
biDiClass=U_FIRST_STRONG_ISOLATE;
}
// Now we verify that the class name is terminated properly,
// and not just the start of a longer word.
int8_t biDiClassNameLength=biDiClassNameLengths[biDiClass];
char c=start[biDiClassNameLength];
if(biDiClass<U_CHAR_DIRECTION_COUNT && (U_IS_INV_WHITESPACE(c) || c==';' || c==0)) {
inputString.append(charFromBiDiClass[biDiClass]);
start+=biDiClassNameLength;
continue;
}
errln("\nError on line %d: BiDi class string not recognized at %s", (int)lineNumber, start);
printErrorLine();
return FALSE;
}
return TRUE;
}
void ErrorCodeTest::TestSubclass() {
int32_t countChecks=0;
int32_t countDests=0;
{
MyErrorCode errorCode(countChecks, countDests);
if( errorCode.get()!=U_ZERO_ERROR || !errorCode.isSuccess() || errorCode.isFailure() ||
countChecks!=0 || countDests!=0
) {
errln("ErrorCode did not initialize properly");
return;
}
errorCode.assertSuccess();
if(countChecks!=0) {
errln("ErrorCode.assertSuccess() called handleFailure() despite success");
}
RefPlusOne(errorCode);
if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
errln("ErrorCode did not yield a writable reference");
}
errorCode.assertSuccess();
if(countChecks!=1) {
errln("ErrorCode.assertSuccess() did not handleFailure()");
}
PtrPlusTwo(errorCode);
if(errorCode.get()!=U_INVALID_FORMAT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
errln("ErrorCode did not yield a writable pointer");
}
errorCode.assertSuccess();
if(countChecks!=2) {
errln("ErrorCode.assertSuccess() did not handleFailure()");
}
errorCode.set(U_PARSE_ERROR);
if(errorCode.get()!=U_PARSE_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
errln("ErrorCode.set() failed");
}
if( errorCode.reset()!=U_PARSE_ERROR || errorCode.get()!=U_ZERO_ERROR ||
!errorCode.isSuccess() || errorCode.isFailure()
) {
errln("ErrorCode did not reset properly");
}
errorCode.assertSuccess();
if(countChecks!=2) {
errln("ErrorCode.assertSuccess() called handleFailure() despite success");
}
}
if(countDests!=0) {
errln("MyErrorCode destructor detected failure despite success");
}
countChecks=countDests=0;
{
MyErrorCode errorCode(countChecks, countDests);
errorCode.set(U_PARSE_ERROR);
}
if(countDests!=1) {
errln("MyErrorCode destructor failed to detect failure");
}
}
void BiDiConformanceTest::TestBidiTest() {
IcuTestErrorCode errorCode(*this, "TestBidiTest");
const char *sourceTestDataPath=getSourceTestData(errorCode);
if(errorCode.logIfFailureAndReset("unable to find the source/test/testdata "
"folder (getSourceTestData())")) {
return;
}
char bidiTestPath[400];
strcpy(bidiTestPath, sourceTestDataPath);
strcat(bidiTestPath, "BidiTest.txt");
LocalStdioFilePointer bidiTestFile(fopen(bidiTestPath, "r"));
if(bidiTestFile.isNull()) {
errln("unable to open %s", bidiTestPath);
return;
}
LocalUBiDiPointer ubidi(ubidi_open());
ubidi_setClassCallback(ubidi.getAlias(), biDiConfUBiDiClassCallback, NULL,
NULL, NULL, errorCode);
if(errorCode.logIfFailureAndReset("ubidi_setClassCallback()")) {
return;
}
lineNumber=0;
levelsCount=0;
orderingCount=0;
errorCount=0;
// paraLevelName must be initialized in case the first non-comment line is in error
paraLevelName="N/A";
while(errorCount<10 && fgets(line, (int)sizeof(line), bidiTestFile.getAlias())!=NULL) {
++lineNumber;
// Remove trailing comments and whitespace.
char *commentStart=strchr(line, '#');
if(commentStart!=NULL) {
*commentStart=0;
}
u_rtrim(line);
const char *start=u_skipWhitespace(line);
if(*start==0) {
continue; // Skip empty and comment-only lines.
}
if(*start=='@') {
++start;
if(0==strncmp(start, "Levels:", 7)) {
start+=7;
if(!parseLevels(start)) {
return;
}
} else if(0==strncmp(start, "Reorder:", 8)) {
if(!parseOrdering(start+8)) {
return;
}
}
// Skip unknown @Xyz: ...
} else {
if(!parseInputStringFromBiDiClasses(start)) {
return;
}
start=u_skipWhitespace(start);
if(*start!=';') {
errln("missing ; separator on input line %s", line);
return;
}
start=u_skipWhitespace(start+1);
char *end;
uint32_t bitset=(uint32_t)strtoul(start, &end, 16);
if(end<=start || (!U_IS_INV_WHITESPACE(*end) && *end!=';' && *end!=0)) {
errln("input bitset parse error at %s", start);
return;
}
// Loop over the bitset.
static const UBiDiLevel paraLevels[]={ UBIDI_DEFAULT_LTR, 0, 1, UBIDI_DEFAULT_RTL };
static const char *const paraLevelNames[]={ "auto/LTR", "LTR", "RTL", "auto/RTL" };
for(int i=0; i<=3; ++i) {
if(bitset&(1<<i)) {
ubidi_setPara(ubidi.getAlias(), inputString.getBuffer(), inputString.length(),
paraLevels[i], NULL, errorCode);
const UBiDiLevel *actualLevels=ubidi_getLevels(ubidi.getAlias(), errorCode);
if(errorCode.logIfFailureAndReset("ubidi_setPara() or ubidi_getLevels()")) {
errln("Input line %d: %s", (int)lineNumber, line);
return;
}
paraLevelName=paraLevelNames[i];
if(!checkLevels(actualLevels, ubidi_getProcessedLength(ubidi.getAlias()))) {
// continue outerLoop; does not exist in C++
// so just break out of the inner loop.
break;
}
if(!checkOrdering(ubidi.getAlias())) {
// continue outerLoop; does not exist in C++
// so just break out of the inner loop.
break;
}
}
}
}
}
}
/**
* Unit tests of PluralFormat class.
*/
void PluralFormatTest::pluralFormatUnitTest(/*char *par*/)
{
UnicodeString patternTestData[PLURAL_PATTERN_DATA] = {
UNICODE_STRING_SIMPLE("odd {# is odd.} other{# is even.}"),
UNICODE_STRING_SIMPLE("other{# is odd or even.}"),
UNICODE_STRING_SIMPLE("odd{The number {0, number, #.#0} is odd.}other{The number {0, number, #.#0} is even.}"),
UNICODE_STRING_SIMPLE("odd{The number {#} is odd.}other{The number {#} is even.}"),
};
UnicodeString patternOddTestResult[PLURAL_PATTERN_DATA] = {
UNICODE_STRING_SIMPLE(" is odd."),
UNICODE_STRING_SIMPLE(" is odd or even."),
UNICODE_STRING_SIMPLE("The number {0, number, #.#0} is odd."),
UNICODE_STRING_SIMPLE("The number {#} is odd."),
};
UnicodeString patternEvenTestResult[PLURAL_PATTERN_DATA] = {
UNICODE_STRING_SIMPLE(" is even."),
UNICODE_STRING_SIMPLE(" is odd or even."),
UNICODE_STRING_SIMPLE("The number {0, number, #.#0} is even."),
UNICODE_STRING_SIMPLE("The number {#} is even."),
};
UnicodeString checkSyntaxtData[PLURAL_SYNTAX_DATA] = {
UNICODE_STRING_SIMPLE("odd{foo} odd{bar} other{foobar}"),
UNICODE_STRING_SIMPLE("odd{foo} other{bar} other{foobar}"),
UNICODE_STRING_SIMPLE("odd{foo}"),
UNICODE_STRING_SIMPLE("otto{foo} other{bar}"),
UNICODE_STRING_SIMPLE("1odd{foo} other{bar}"),
UNICODE_STRING_SIMPLE("odd{foo},other{bar}"),
UNICODE_STRING_SIMPLE("od d{foo} other{bar}"),
UNICODE_STRING_SIMPLE("odd{foo}{foobar}other{foo}"),
};
UErrorCode status = U_ZERO_ERROR;
UnicodeString oddAndEvenRule = UNICODE_STRING_SIMPLE("odd: n mod 2 is 1");
PluralRules* plRules = PluralRules::createRules(oddAndEvenRule, status);
if (U_FAILURE(status)) {
dataerrln("ERROR: create PluralRules instance failed in unit tests.- exitting");
return;
}
// ======= Test PluralRules pattern syntax.
logln("Testing PluralRules pattern syntax.");
for (int32_t i=0; i<PLURAL_SYNTAX_DATA; ++i) {
status = U_ZERO_ERROR;
PluralFormat plFmt=PluralFormat(*plRules, status);
if (U_FAILURE(status)) {
dataerrln("ERROR: PluralFormat constructor failed in unit tests.- exitting");
return;
}
plFmt.applyPattern(checkSyntaxtData[i], status);
if (U_SUCCESS(status)) {
errln("ERROR: PluralFormat failed to detect syntax error with pattern: "+checkSyntaxtData[i]);
}
}
// ======= Test applying various pattern
logln("Testing various patterns");
status = U_ZERO_ERROR;
UBool overwrite[PLURAL_PATTERN_DATA] = {FALSE, FALSE, TRUE, TRUE};
NumberFormat *numFmt = NumberFormat::createInstance(status);
UnicodeString message=UnicodeString("ERROR: PluralFormat tests various pattern ...");
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not create NumberFormat instance with default locale ");
}
for(int32_t i=0; i<PLURAL_PATTERN_DATA; ++i) {
status = U_ZERO_ERROR;
PluralFormat plFmt=PluralFormat(*plRules, status);
if (U_FAILURE(status)) {
dataerrln("ERROR: PluralFormat constructor failed in unit tests.- exitting");
return;
}
plFmt.applyPattern(patternTestData[i], status);
if (U_FAILURE(status)) {
errln("ERROR: PluralFormat failed to apply pattern- "+patternTestData[i]);
continue;
}
numberFormatTest(&plFmt, numFmt, 1, 10, (UnicodeString *)&patternOddTestResult[i],
(UnicodeString *)&patternEvenTestResult[i], overwrite[i], &message);
}
delete plRules;
delete numFmt;
// ======= Test set locale
status = U_ZERO_ERROR;
plRules = PluralRules::createRules(UNICODE_STRING_SIMPLE("odd: n mod 2 is 1"), status);
PluralFormat pluralFmt = PluralFormat(*plRules, status);
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not create PluralFormat instance in setLocale() test - exitting. ");
delete plRules;
return;
}
pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("odd{odd} other{even}"), status);
pluralFmt.setLocale(Locale::getEnglish(), status);
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not setLocale() with English locale ");
delete plRules;
return;
}
message = UNICODE_STRING_SIMPLE("Error set locale: pattern is not reset!");
// Check that pattern gets deleted.
logln("\n Test setLocale() ..\n");
numFmt = NumberFormat::createInstance(Locale::getEnglish(), status);
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not create NumberFormat instance with English locale ");
}
numberFormatTest(&pluralFmt, numFmt, 5, 5, NULL, NULL, FALSE, &message);
pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("odd__{odd} other{even}"), status);
if (U_SUCCESS(status)) {
errln("SetLocale should reset rules but did not.");
}
status = U_ZERO_ERROR;
pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("one{one} other{not one}"), status);
if (U_FAILURE(status)) {
errln("SetLocale should reset rules but did not.");
}
UnicodeString one = UNICODE_STRING_SIMPLE("one");
UnicodeString notOne = UNICODE_STRING_SIMPLE("not one");
UnicodeString plResult, numResult;
for (int32_t i=0; i<20; ++i) {
plResult = pluralFmt.format(i, status);
if ( i==1 ) {
numResult = one;
}
else {
numResult = notOne;
}
if ( numResult != plResult ) {
errln("Wrong ruleset loaded by setLocale() - got:"+plResult+ UnicodeString(" expecting:")+numResult);
}
}
// =========== Test copy constructor
logln("Test copy constructor and == operator of PluralFormat");
PluralFormat dupPFmt = PluralFormat(pluralFmt);
if (pluralFmt != dupPFmt) {
errln("Failed in PluralFormat copy constructor or == operator");
}
delete plRules;
delete numFmt;
}
/*
*******************************************************************************
*
* created on: 2013jul01
* created by: Matitiahu Allouche
This function performs a conformance test for implementations of the
Unicode Bidirectional Algorithm, specified in UAX #9: Unicode
Bidirectional Algorithm, at http://www.unicode.org/unicode/reports/tr9/
Each test case is represented in a single line which is read from a file
named BidiCharacter.txt. Empty, blank and comment lines may also appear
in this file.
The format of the test data is specified below. Note that each test
case constitutes a single line of text; reordering is applied within a
single line and independently of a rendering engine, and rules L3 and L4
are out of scope.
The number sign '#' is the comment character: everything is ignored from
the occurrence of '#' until the end of the line,
Empty lines and lines containing only spaces and/or comments are ignored.
Lines which represent test cases consist of 4 or 5 fields separated by a
semicolon. Each field consists of tokens separated by whitespace (space
or Tab). Whitespace before and after semicolons is optional.
Field 0: A sequence of hexadecimal code point values separated by space
Field 1: A value representing the paragraph direction, as follows:
- 0 represents left-to-right
- 1 represents right-to-left
- 2 represents auto-LTR according to rules P2 and P3 of the algorithm
- 3 represents auto-RTL according to rules P2 and P3 of the algorithm
- a negative number whose absolute value is taken as paragraph level;
this may be useful to test cases where the embedding level approaches
or exceeds the maximum embedding level.
Field 2: The resolved paragraph embedding level. If the input (field 0)
includes more than one paragraph, this field represents the
resolved level of the first paragraph.
Field 3: An ordered list of resulting levels for each token in field 0
(each token represents one source character).
The UBA does not assign levels to certain characters (e.g. LRO);
characters removed in rule X9 are indicated with an 'x'.
Field 4: An ordered list of indices showing the resulting visual ordering
from left to right; characters with a resolved level of 'x' are
skipped. The number are zero-based. Each index corresponds to
a character in the reordered (visual) string. It represents the
index of the source character in the input (field 0).
This field is optional. When it is absent, the visual ordering
is not verified.
Examples:
# This is a comment line.
L L ON R ; 0 ; 0 ; 0 0 0 1 ; 0 1 2 3
L L ON R;0;0;0 0 0 1;0 1 2 3
# Note: in the next line, 'B' represents a block separator, not the letter 'B'.
LRE A B C PDF;2;0;x 2 0 0 x;1 2 3
# Note: in the next line, 'b' represents the letter 'b', not a block separator.
a b c 05d0 05d1 x ; 0 ; 0 ; 0 0 0 1 1 0 ; 0 1 2 4 3 5
a R R x ; 1 ; 1 ; 2 1 1 2
L L R R R B R R L L L B ON ON ; 3 ; 0 ; 0 0 1 1 1 0 1 1 2 2 2 1 1 1
*
*******************************************************************************
*/
void BiDiConformanceTest::TestBidiCharacterTest() {
IcuTestErrorCode errorCode(*this, "TestBidiCharacterTest");
const char *sourceTestDataPath=getSourceTestData(errorCode);
if(errorCode.logIfFailureAndReset("unable to find the source/test/testdata "
"folder (getSourceTestData())")) {
return;
}
char bidiTestPath[400];
strcpy(bidiTestPath, sourceTestDataPath);
strcat(bidiTestPath, "BidiCharacterTest.txt");
LocalStdioFilePointer bidiTestFile(fopen(bidiTestPath, "r"));
if(bidiTestFile.isNull()) {
errln("unable to open %s", bidiTestPath);
return;
}
LocalUBiDiPointer ubidi(ubidi_open());
lineNumber=0;
levelsCount=0;
orderingCount=0;
errorCount=0;
while(errorCount<20 && fgets(line, (int)sizeof(line), bidiTestFile.getAlias())!=NULL) {
++lineNumber;
paraLevelName="N/A";
inputString="N/A";
// Remove trailing comments and whitespace.
char *commentStart=strchr(line, '#');
if(commentStart!=NULL) {
*commentStart=0;
}
u_rtrim(line);
const char *start=u_skipWhitespace(line);
if(*start==0) {
continue; // Skip empty and comment-only lines.
}
// Parse the code point string in field 0.
UChar *buffer=inputString.getBuffer(200);
int32_t length=u_parseString(start, buffer, inputString.getCapacity(), NULL, errorCode);
if(errorCode.logIfFailureAndReset("Invalid string in field 0")) {
errln("Input line %d: %s", (int)lineNumber, line);
inputString.remove();
continue;
}
inputString.releaseBuffer(length);
start=strchr(start, ';');
if(start==NULL) {
errorCount++;
errln("\nError on line %d: Missing ; separator on line: %s", (int)lineNumber, line);
continue;
}
start=u_skipWhitespace(start+1);
char *end;
int32_t paraDirection=(int32_t)strtol(start, &end, 10);
UBiDiLevel paraLevel=UBIDI_MAX_EXPLICIT_LEVEL+2;
if(paraDirection==0) {
paraLevel=0;
paraLevelName="LTR";
}
else if(paraDirection==1) {
paraLevel=1;
paraLevelName="RTL";
}
else if(paraDirection==2) {
paraLevel=UBIDI_DEFAULT_LTR;
paraLevelName="Auto/LTR";
}
else if(paraDirection==3) {
paraLevel=UBIDI_DEFAULT_RTL;
paraLevelName="Auto/RTL";
}
else if(paraDirection<0 && -paraDirection<=(UBIDI_MAX_EXPLICIT_LEVEL+1)) {
paraLevel=(UBiDiLevel)(-paraDirection);
sprintf(levelNameString, "%d", (int)paraLevel);
paraLevelName=levelNameString;
}
if(end<=start || (!U_IS_INV_WHITESPACE(*end) && *end!=';' && *end!=0) ||
paraLevel==(UBIDI_MAX_EXPLICIT_LEVEL+2)) {
errln("\nError on line %d: Input paragraph direction incorrect at %s", (int)lineNumber, start);
printErrorLine();
continue;
}
start=u_skipWhitespace(end);
if(*start!=';') {
errorCount++;
errln("\nError on line %d: Missing ; separator on line: %s", (int)lineNumber, line);
continue;
}
start++;
uint32_t resolvedParaLevel=(uint32_t)strtoul(start, &end, 10);
if(end<=start || (!U_IS_INV_WHITESPACE(*end) && *end!=';' && *end!=0) ||
resolvedParaLevel>1) {
errln("\nError on line %d: Resolved paragraph level incorrect at %s", (int)lineNumber, start);
printErrorLine();
continue;
}
start=u_skipWhitespace(end);
if(*start!=';') {
errorCount++;
errln("\nError on line %d: Missing ; separator on line: %s", (int)lineNumber, line);
return;
}
start++;
if(!parseLevels(start)) {
continue;
}
start=u_skipWhitespace(start);
if(*start==';') {
if(!parseOrdering(start+1)) {
continue;
}
}
else
orderingCount=-1;
ubidi_setPara(ubidi.getAlias(), inputString.getBuffer(), inputString.length(),
paraLevel, NULL, errorCode);
const UBiDiLevel *actualLevels=ubidi_getLevels(ubidi.getAlias(), errorCode);
if(errorCode.logIfFailureAndReset("ubidi_setPara() or ubidi_getLevels()")) {
errln("Input line %d: %s", (int)lineNumber, line);
continue;
}
UBiDiLevel actualLevel;
if((actualLevel=ubidi_getParaLevel(ubidi.getAlias()))!=resolvedParaLevel) {
printErrorLine();
errln("\nError on line %d: Wrong resolved paragraph level; expected %d actual %d",
(int)lineNumber, resolvedParaLevel, actualLevel);
continue;
}
if(!checkLevels(actualLevels, ubidi_getProcessedLength(ubidi.getAlias()))) {
continue;
}
if(orderingCount>=0 && !checkOrdering(ubidi.getAlias())) {
continue;
}
}
}
void UnicodeTest::TestAdditionalProperties() {
// test DerivedCoreProperties.txt
if(LENGTHOF(derivedCoreProps)<LENGTHOF(derivedCorePropsNames)) {
errln("error: UnicodeTest::derivedCoreProps[] too short, need at least %d UnicodeSets\n",
LENGTHOF(derivedCorePropsNames));
return;
}
if(LENGTHOF(derivedCorePropsIndex)!=LENGTHOF(derivedCorePropsNames)) {
errln("error in ucdtest.cpp: LENGTHOF(derivedCorePropsIndex)!=LENGTHOF(derivedCorePropsNames)\n");
return;
}
char newPath[256];
char backupPath[256];
char *fields[2][2];
UErrorCode errorCode=U_ZERO_ERROR;
/* Look inside ICU_DATA first */
strcpy(newPath, pathToDataDirectory());
strcat(newPath, "unidata" U_FILE_SEP_STRING "DerivedCoreProperties.txt");
// As a fallback, try to guess where the source data was located
// at the time ICU was built, and look there.
# ifdef U_TOPSRCDIR
strcpy(backupPath, U_TOPSRCDIR U_FILE_SEP_STRING "data");
# else
strcpy(backupPath, loadTestData(errorCode));
strcat(backupPath, U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data");
# endif
strcat(backupPath, U_FILE_SEP_STRING);
strcat(backupPath, "unidata" U_FILE_SEP_STRING "DerivedCoreProperties.txt");
u_parseDelimitedFile(newPath, ';', fields, 2, derivedCorePropsLineFn, this, &errorCode);
if(errorCode==U_FILE_ACCESS_ERROR) {
errorCode=U_ZERO_ERROR;
u_parseDelimitedFile(backupPath, ';', fields, 2, derivedCorePropsLineFn, this, &errorCode);
}
if(U_FAILURE(errorCode)) {
errln("error parsing DerivedCoreProperties.txt: %s\n", u_errorName(errorCode));
return;
}
// now we have all derived core properties in the UnicodeSets
// run them all through the API
int32_t rangeCount, range;
uint32_t i;
UChar32 start, end;
int32_t noErrors = 0;
// test all TRUE properties
for(i=0; i<LENGTHOF(derivedCorePropsNames); ++i) {
rangeCount=derivedCoreProps[i].getRangeCount();
for(range=0; range<rangeCount; ++range) {
start=derivedCoreProps[i].getRangeStart(range);
end=derivedCoreProps[i].getRangeEnd(range);
for(; start<=end; ++start) {
if(!u_hasBinaryProperty(start, derivedCorePropsIndex[i])) {
errln("UnicodeTest error: u_hasBinaryProperty(U+%04lx, %s)==FALSE is wrong\n", start, derivedCorePropsNames[i]);
if(noErrors++ > 100) {
errln("Too many errors, moving to the next test");
break;
}
}
}
}
}
noErrors = 0;
// invert all properties
for(i=0; i<LENGTHOF(derivedCorePropsNames); ++i) {
derivedCoreProps[i].complement();
}
// test all FALSE properties
for(i=0; i<LENGTHOF(derivedCorePropsNames); ++i) {
rangeCount=derivedCoreProps[i].getRangeCount();
for(range=0; range<rangeCount; ++range) {
start=derivedCoreProps[i].getRangeStart(range);
end=derivedCoreProps[i].getRangeEnd(range);
for(; start<=end; ++start) {
if(u_hasBinaryProperty(start, derivedCorePropsIndex[i])) {
errln("UnicodeTest error: u_hasBinaryProperty(U+%04lx, %s)==TRUE is wrong\n", start, derivedCorePropsNames[i]);
if(noErrors++ > 100) {
errln("Too many errors, moving to the next test");
break;
}
}
}
}
}
}
void BiDiConformanceTest::printErrorLine() {
++errorCount;
errln("Input line %5d: %s", (int)lineNumber, line);
errln(UnicodeString("Input string: ")+inputString);
errln("Para level: %s", paraLevelName);
}
void CollationServiceTest::TestRegisterFactory(void)
{
#if !UCONFIG_NO_SERVICE
int32_t n1, n2, n3;
Locale fu_FU("fu", "FU", "");
Locale fu_FU_FOO("fu", "FU", "FOO");
UErrorCode status = U_ZERO_ERROR;
Hashtable* fuFUNames = new Hashtable(FALSE, status);
if (!fuFUNames) {
errln("memory allocation error");
return;
}
fuFUNames->setValueDeleter(uprv_deleteUObject);
fuFUNames->put(fu_FU.getName(), new UnicodeString("ze leetle bunny Fu-Fu"), status);
fuFUNames->put(fu_FU_FOO.getName(), new UnicodeString("zee leetel bunny Foo-Foo"), status);
fuFUNames->put(Locale::getDefault().getName(), new UnicodeString("little bunny Foo Foo"), status);
Collator* frcol = Collator::createInstance(Locale::getFrance(), status);
Collator* gecol = Collator::createInstance(Locale::getGermany(), status);
Collator* jpcol = Collator::createInstance(Locale::getJapan(), status);
if(U_FAILURE(status)) {
errcheckln(status, "Failed to create collators with %s", u_errorName(status));
delete frcol;
delete gecol;
delete jpcol;
delete fuFUNames;
return;
}
CollatorInfo** info = new CollatorInfo*[4];
if (!info) {
errln("memory allocation error");
return;
}
info[0] = new CollatorInfo(Locale::getUS(), frcol, NULL);
info[1] = new CollatorInfo(Locale::getFrance(), gecol, NULL);
info[2] = new CollatorInfo(fu_FU, jpcol, fuFUNames);
info[3] = NULL;
TestFactory* factory = new TestFactory(info);
if (!factory) {
errln("memory allocation error");
return;
}
Collator* uscol = Collator::createInstance(Locale::getUS(), status);
Collator* fucol = Collator::createInstance(fu_FU, status);
{
n1 = checkAvailable("before registerFactory");
URegistryKey key = Collator::registerFactory(factory, status);
n2 = checkAvailable("after registerFactory");
assertTrue("count after > count before", n2 > n1);
Collator* ncol = Collator::createInstance(Locale::getUS(), status);
if (*frcol != *ncol) {
errln("frcoll for en_US failed");
}
delete ncol; ncol = NULL;
ncol = Collator::createInstance(fu_FU_FOO, status);
if (*jpcol != *ncol) {
errln("jpcol for fu_FU_FOO failed");
}
// The requested locale may be the same as the valid locale,
// or may not be supported at all. See ticket #10477.
Locale loc = ncol->getLocale(ULOC_REQUESTED_LOCALE, status);
if (U_SUCCESS(status) && loc != fu_FU_FOO && loc != fu_FU) {
errln(UnicodeString("requested locale for fu_FU_FOO is not fu_FU_FOO nor fu_FU but ") + loc.getName());
}
status = U_ZERO_ERROR;
loc = ncol->getLocale(ULOC_VALID_LOCALE, status);
if (loc != fu_FU) {
errln(UnicodeString("valid locale for fu_FU_FOO is not fu_FU but ") + loc.getName());
}
delete ncol; ncol = NULL;
UnicodeString locName = fu_FU.getName();
StringEnumeration* localeEnum = Collator::getAvailableLocales();
UBool found = FALSE;
const UnicodeString* locStr;
for (locStr = localeEnum->snext(status);
!found && locStr != NULL;
locStr = localeEnum->snext(status))
{
if (locName == *locStr) {
found = TRUE;
}
}
delete localeEnum;
if (!found) {
errln("new locale fu_FU not reported as supported locale");
}
UnicodeString name;
Collator::getDisplayName(fu_FU, name);
if (name != "little bunny Foo Foo") {
errln(UnicodeString("found ") + name + " for fu_FU");
}
Collator::getDisplayName(fu_FU, fu_FU_FOO, name);
if (name != "zee leetel bunny Foo-Foo") {
errln(UnicodeString("found ") + name + " for fu_FU in fu_FU_FOO");
}
if (!Collator::unregister(key, status)) {
errln("failed to unregister factory");
}
// ja, fr, ge collators no longer valid
ncol = Collator::createInstance(fu_FU, status);
if (*fucol != *ncol) {
errln("collator after unregister does not match original fu_FU");
}
delete ncol;
n3 = checkAvailable("after unregister");
assertTrue("count after unregister == count before register", n3 == n1);
}
delete fucol;
delete uscol;
#endif
}
void SimplePatternFormatterTest::TestManyPlaceholders() {
UErrorCode status = U_ZERO_ERROR;
SimplePatternFormatter fmt;
fmt.compile(
"Templates {2}{1}{5} and {4} are out of order.", status);
assertSuccess("Status", status);
assertFalse("startsWithPlaceholder", fmt.startsWithPlaceholder(2));
assertEquals("PlaceholderCount", 6, fmt.getPlaceholderCount());
UnicodeString values[] = {
"freddy", "tommy", "frog", "billy", "leg", "{0}"};
UnicodeString *params[] = {
&values[0], &values[1], &values[2], &values[3], &values[4], &values[5]};
int32_t offsets[6];
int32_t expectedOffsets[6] = {-1, 22, 18, -1, 35, 27};
UnicodeString appendTo("Prefix: ");
assertEquals(
"format",
"Prefix: Templates frogtommy{0} and leg are out of order.",
fmt.format(
params,
UPRV_LENGTHOF(params),
appendTo,
offsets,
UPRV_LENGTHOF(offsets),
status));
assertSuccess("Status", status);
for (int32_t i = 0; i < UPRV_LENGTHOF(expectedOffsets); ++i) {
if (expectedOffsets[i] != offsets[i]) {
errln("Expected %d, got %d", expectedOffsets[i], offsets[i]);
}
}
appendTo.remove();
// Not having enough placeholder params results in error.
fmt.format(
params,
UPRV_LENGTHOF(params) - 1,
appendTo,
offsets,
UPRV_LENGTHOF(offsets),
status);
if (status != U_ILLEGAL_ARGUMENT_ERROR) {
errln("Expected U_ILLEGAL_ARGUMENT_ERROR");
}
// Ensure we don't write to offsets array beyond its length.
status = U_ZERO_ERROR;
offsets[UPRV_LENGTHOF(offsets) - 1] = 289;
appendTo.remove();
fmt.format(
params,
UPRV_LENGTHOF(params),
appendTo,
offsets,
UPRV_LENGTHOF(offsets) - 1,
status);
assertEquals("Offsets buffer length", 289, offsets[UPRV_LENGTHOF(offsets) - 1]);
// Test assignment
SimplePatternFormatter s;
s = fmt;
appendTo.remove();
assertEquals(
"Assignment",
"Templates frogtommy{0} and leg are out of order.",
s.format(
params,
UPRV_LENGTHOF(params),
appendTo,
NULL,
0,
status));
// Copy constructor
SimplePatternFormatter r(fmt);
appendTo.remove();
assertEquals(
"Copy constructor",
"Templates frogtommy{0} and leg are out of order.",
r.format(
params,
UPRV_LENGTHOF(params),
appendTo,
NULL,
0,
status));
r.compile("{0} meter", status);
assertEquals("PlaceholderCount", 1, r.getPlaceholderCount());
appendTo.remove();
assertEquals(
"Replace with new compile",
"freddy meter",
r.format("freddy", appendTo, status));
r.compile("{0}, {1}", status);
assertEquals("PlaceholderCount", 2, r.getPlaceholderCount());
appendTo.remove();
assertEquals(
"2 arg",
"foo, bar",
r.format("foo", "bar", appendTo, status));
r.compile("{0}, {1} and {2}", status);
assertEquals("PlaceholderCount", 3, r.getPlaceholderCount());
appendTo.remove();
assertEquals(
"3 arg",
"foo, bar and baz",
r.format("foo", "bar", "baz", appendTo, status));
assertSuccess("Status", status);
}
void
CalendarLimitTest::doTheoreticalLimitsTest(Calendar& cal, UBool leapMonth) {
const char* calType = cal.getType();
int32_t nDOW = cal.getMaximum(UCAL_DAY_OF_WEEK);
int32_t maxDOY = cal.getMaximum(UCAL_DAY_OF_YEAR);
int32_t lmaxDOW = cal.getLeastMaximum(UCAL_DAY_OF_YEAR);
int32_t maxWOY = cal.getMaximum(UCAL_WEEK_OF_YEAR);
int32_t lmaxWOY = cal.getLeastMaximum(UCAL_WEEK_OF_YEAR);
int32_t maxM = cal.getMaximum(UCAL_MONTH) + 1;
int32_t lmaxM = cal.getLeastMaximum(UCAL_MONTH) + 1;
int32_t maxDOM = cal.getMaximum(UCAL_DAY_OF_MONTH);
int32_t lmaxDOM = cal.getLeastMaximum(UCAL_DAY_OF_MONTH);
int32_t maxDOWIM = cal.getMaximum(UCAL_DAY_OF_WEEK_IN_MONTH);
int32_t lmaxDOWIM = cal.getLeastMaximum(UCAL_DAY_OF_WEEK_IN_MONTH);
int32_t maxWOM = cal.getMaximum(UCAL_WEEK_OF_MONTH);
int32_t lmaxWOM = cal.getLeastMaximum(UCAL_WEEK_OF_MONTH);
int32_t minDaysInFirstWeek = cal.getMinimalDaysInFirstWeek();
// Day of year
int32_t expected;
if (!leapMonth) {
expected = maxM*maxDOM;
if (maxDOY > expected) {
errln((UnicodeString)"FAIL: [" + calType + "] Maximum value of DAY_OF_YEAR is too big: "
+ maxDOY + "/expected: <=" + expected);
}
expected = lmaxM*lmaxDOM;
if (lmaxDOW < expected) {
errln((UnicodeString)"FAIL: [" + calType + "] Least maximum value of DAY_OF_YEAR is too small: "
+ lmaxDOW + "/expected: >=" + expected);
}
}
// Week of year
expected = maxDOY/nDOW + 1;
if (maxWOY > expected) {
errln((UnicodeString)"FAIL: [" + calType + "] Maximum value of WEEK_OF_YEAR is too big: "
+ maxWOY + "/expected: <=" + expected);
}
expected = lmaxDOW/nDOW;
if (lmaxWOY < expected) {
errln((UnicodeString)"FAIL: [" + calType + "] Least maximum value of WEEK_OF_YEAR is too small: "
+ lmaxWOY + "/expected >=" + expected);
}
// Day of week in month
expected = (maxDOM + nDOW - 1)/nDOW;
if (maxDOWIM != expected) {
errln((UnicodeString)"FAIL: [" + calType + "] Maximum value of DAY_OF_WEEK_IN_MONTH is incorrect: "
+ maxDOWIM + "/expected: " + expected);
}
expected = (lmaxDOM + nDOW - 1)/nDOW;
if (lmaxDOWIM != expected) {
errln((UnicodeString)"FAIL: [" + calType + "] Least maximum value of DAY_OF_WEEK_IN_MONTH is incorrect: "
+ lmaxDOWIM + "/expected: " + expected);
}
// Week of month
expected = (maxDOM + (nDOW - 1) + (nDOW - minDaysInFirstWeek)) / nDOW;
if (maxWOM != expected) {
errln((UnicodeString)"FAIL: [" + calType + "] Maximum value of WEEK_OF_MONTH is incorrect: "
+ maxWOM + "/expected: " + expected);
}
expected = (lmaxDOM + (nDOW - minDaysInFirstWeek)) / nDOW;
if (lmaxWOM != expected) {
errln((UnicodeString)"FAIL: [" + calType + "] Least maximum value of WEEK_OF_MONTH is incorrect: "
+ lmaxWOM + "/expected: " + expected);
}
}
void CalendarCaseTest::IslamicCivil()
{
static const TestCase tests[] = {
//
// Most of these test cases were taken from the back of
// "Calendrical Calculations", with some extras added to help
// debug a few of the problems that cropped up in development.
//
// The months in this table are 1-based rather than 0-based,
// because it's easier to edit that way.
// Islamic
// Julian Day Era Year Month Day WkDay Hour Min Sec
{ 1507231.5, 0, -1245, 12, 9, SUN, 0, 0, 0},
{ 1660037.5, 0, -813, 2, 23, WED, 0, 0, 0},
{ 1746893.5, 0, -568, 4, 1, WED, 0, 0, 0},
{ 1770641.5, 0, -501, 4, 6, SUN, 0, 0, 0},
{ 1892731.5, 0, -157, 10, 17, WED, 0, 0, 0},
{ 1931579.5, 0, -47, 6, 3, MON, 0, 0, 0},
{ 1974851.5, 0, 75, 7, 13, SAT, 0, 0, 0},
{ 2091164.5, 0, 403, 10, 5, SUN, 0, 0, 0},
{ 2121509.5, 0, 489, 5, 22, SUN, 0, 0, 0},
{ 2155779.5, 0, 586, 2, 7, FRI, 0, 0, 0},
{ 2174029.5, 0, 637, 8, 7, SAT, 0, 0, 0},
{ 2191584.5, 0, 687, 2, 20, FRI, 0, 0, 0},
{ 2195261.5, 0, 697, 7, 7, SUN, 0, 0, 0},
{ 2229274.5, 0, 793, 7, 1, SUN, 0, 0, 0},
{ 2245580.5, 0, 839, 7, 6, WED, 0, 0, 0},
{ 2266100.5, 0, 897, 6, 1, SAT, 0, 0, 0},
{ 2288542.5, 0, 960, 9, 30, SAT, 0, 0, 0},
{ 2290901.5, 0, 967, 5, 27, SAT, 0, 0, 0},
{ 2323140.5, 0, 1058, 5, 18, WED, 0, 0, 0},
{ 2334848.5, 0, 1091, 6, 2, SUN, 0, 0, 0},
{ 2348020.5, 0, 1128, 8, 4, FRI, 0, 0, 0},
{ 2366978.5, 0, 1182, 2, 3, SUN, 0, 0, 0},
{ 2385648.5, 0, 1234, 10, 10, MON, 0, 0, 0},
{ 2392825.5, 0, 1255, 1, 11, WED, 0, 0, 0},
{ 2416223.5, 0, 1321, 1, 21, SUN, 0, 0, 0},
{ 2425848.5, 0, 1348, 3, 19, SUN, 0, 0, 0},
{ 2430266.5, 0, 1360, 9, 8, MON, 0, 0, 0},
{ 2430833.5, 0, 1362, 4, 13, MON, 0, 0, 0},
{ 2431004.5, 0, 1362, 10, 7, THU, 0, 0, 0},
{ 2448698.5, 0, 1412, 9, 13, TUE, 0, 0, 0},
{ 2450138.5, 0, 1416, 10, 5, SUN, 0, 0, 0},
{ 2465737.5, 0, 1460, 10, 12, WED, 0, 0, 0},
{ 2486076.5, 0, 1518, 3, 5, SUN, 0, 0, 0},
{ -1,-1,-1,-1,-1,-1,-1,-1,-1 }
};
UErrorCode status = U_ZERO_ERROR;
Calendar *c = Calendar::createInstance("ar@calendar=islamic-civil", status);
if (failure(status, "Calendar::createInstance", TRUE)) return;
c->setLenient(TRUE);
doTestCases(tests, c);
static const UChar expectedUChars[] = {
0x0627, 0x0644, 0x062e, 0x0645, 0x064a, 0x0633, 0x060c, 0x0020, 0x0662, 0x0662, 0x0020,
0x0634, 0x0648, 0x0627, 0x0644, 0x0020, 0x0661, 0x0663, 0x0668, 0x0669, 0x0020, 0x0647, 0x0640, 0
};
UnicodeString result;
DateFormat *fmt = DateFormat::createDateInstance(DateFormat::kFull, Locale("ar_JO@calendar=islamic-civil"));
if (fmt == NULL) {
dataerrln("Error calling DateFormat::createDateInstance");
delete c;
return;
}
fmt->setTimeZone(*TimeZone::getGMT());
fmt->format((UDate)2486076.5, result);
if (result != expectedUChars) {
errln((UnicodeString)"FAIL: DateFormatting failed. Got " + result + " and expected " + UnicodeString(expectedUChars) + UnicodeString("\n"));
errln("Maybe the resource aliasing isn't working");
}
delete fmt;
delete c;
}
void NormalizerConformanceTest::TestConformance(FileStream *input, int32_t options) {
enum { BUF_SIZE = 1024 };
char lineBuf[BUF_SIZE];
UnicodeString fields[FIELD_COUNT];
UErrorCode status = U_ZERO_ERROR;
int32_t passCount = 0;
int32_t failCount = 0;
UChar32 c;
if(input==NULL) {
return;
}
// UnicodeSet for all code points that are not mentioned in NormalizationTest.txt
UnicodeSet other(0, 0x10ffff);
int32_t count, countMoreCases = sizeof(moreCases)/sizeof(moreCases[0]);
for (count = 1;;++count) {
if (!T_FileStream_eof(input)) {
T_FileStream_readLine(input, lineBuf, (int32_t)sizeof(lineBuf));
} else {
// once NormalizationTest.txt is finished, use moreCases[]
if(count > countMoreCases) {
count = 0;
} else if(count == countMoreCases) {
// all done
break;
}
uprv_strcpy(lineBuf, moreCases[count]);
}
if (lineBuf[0] == 0 || lineBuf[0] == '\n' || lineBuf[0] == '\r') continue;
// Expect 5 columns of this format:
// 1E0C;1E0C;0044 0323;1E0C;0044 0323; # <comments>
// Parse out the comment.
if (lineBuf[0] == '#') continue;
// Read separator lines starting with '@'
if (lineBuf[0] == '@') {
logln(lineBuf);
continue;
}
// Parse out the fields
if (!hexsplit(lineBuf, ';', fields, FIELD_COUNT)) {
errln((UnicodeString)"Unable to parse line " + count);
break; // Syntax error
}
// Remove a single code point from the "other" UnicodeSet
if(fields[0].length()==fields[0].moveIndex32(0, 1)) {
c=fields[0].char32At(0);
if(0xac20<=c && c<=0xd73f && quick) {
// not an exhaustive test run: skip most Hangul syllables
if(c==0xac20) {
other.remove(0xac20, 0xd73f);
}
continue;
}
other.remove(c);
}
if (checkConformance(fields, lineBuf, options, status)) {
++passCount;
} else {
++failCount;
if(status == U_FILE_ACCESS_ERROR) {
errln("Something is wrong with the normalizer, skipping the rest of the test.");
break;
}
}
if ((count % 1000) == 0) {
logln("Line %d", count);
}
}
T_FileStream_close(input);
/*
* Test that all characters that are not mentioned
* as single code points in column 1
* do not change under any normalization.
*/
// remove U+ffff because that is the end-of-iteration sentinel value
other.remove(0xffff);
for(c=0; c<=0x10ffff; quick ? c+=113 : ++c) {
if(0x30000<=c && c<0xe0000) {
c=0xe0000;
}
if(!other.contains(c)) {
continue;
}
fields[0]=fields[1]=fields[2]=fields[3]=fields[4].setTo(c);
sprintf(lineBuf, "not mentioned code point U+%04lx", (long)c);
if (checkConformance(fields, lineBuf, options, status)) {
++passCount;
} else {
++failCount;
if(status == U_FILE_ACCESS_ERROR) {
errln("Something is wrong with the normalizer, skipping the rest of the test.");
break;
}
}
if ((c % 0x1000) == 0) {
logln("Code point U+%04lx", c);
}
}
if (failCount != 0) {
errln((UnicodeString)"Total: " + failCount + " lines/code points failed, " +
passCount + " lines/code points passed");
} else {
logln((UnicodeString)"Total: " + passCount + " lines/code points passed");
}
}
void DateFormatRegressionTest::Test4052408(void)
{
DateFormat *fmt = DateFormat::createDateTimeInstance(DateFormat::SHORT,
DateFormat::SHORT, Locale::getUS());
if (fmt == NULL) {
dataerrln("Error calling DateFormat::createDateTimeInstance");
return;
}
UDate dt = date(97, UCAL_MAY, 3, 8, 55);
UnicodeString str;
str = fmt->format(dt, str);
logln(str);
if(str != "5/3/97 8:55 AM")
errln("Fail: Test broken; Want 5/3/97 8:55 AM Got " + str);
UnicodeString expected[] = {
(UnicodeString) "", //"ERA_FIELD",
(UnicodeString) "97", //"YEAR_FIELD",
(UnicodeString) "5", //"MONTH_FIELD",
(UnicodeString) "3", //"DATE_FIELD",
(UnicodeString) "", //"HOUR_OF_DAY1_FIELD",
(UnicodeString) "", //"HOUR_OF_DAY0_FIELD",
(UnicodeString) "55", //"MINUTE_FIELD",
(UnicodeString) "", //"SECOND_FIELD",
(UnicodeString) "", //"MILLISECOND_FIELD",
(UnicodeString) "", //"DAY_OF_WEEK_FIELD",
(UnicodeString) "", //"DAY_OF_YEAR_FIELD",
(UnicodeString) "", //"DAY_OF_WEEK_IN_MONTH_FIELD",
(UnicodeString) "", //"WEEK_OF_YEAR_FIELD",
(UnicodeString) "", //"WEEK_OF_MONTH_FIELD",
(UnicodeString) "AM", //"AM_PM_FIELD",
(UnicodeString) "8", //"HOUR1_FIELD",
(UnicodeString) "", //"HOUR0_FIELD",
(UnicodeString) "" //"TIMEZONE_FIELD"
};
//Hashtable expected;// = new Hashtable();
//expected.put(new LongKey(DateFormat.MONTH_FIELD), "5");
//expected.put(new LongKey(DateFormat.DATE_FIELD), "3");
//expected.put(new LongKey(DateFormat.YEAR_FIELD), "97");
//expected.put(new LongKey(DateFormat.HOUR1_FIELD), "8");
//expected.put(new LongKey(DateFormat.MINUTE_FIELD), "55");
//expected.put(new LongKey(DateFormat.AM_PM_FIELD), "AM");
//StringBuffer buf = new StringBuffer();
UnicodeString fieldNames[] = {
(UnicodeString) "ERA_FIELD",
(UnicodeString) "YEAR_FIELD",
(UnicodeString) "MONTH_FIELD",
(UnicodeString) "DATE_FIELD",
(UnicodeString) "HOUR_OF_DAY1_FIELD",
(UnicodeString) "HOUR_OF_DAY0_FIELD",
(UnicodeString) "MINUTE_FIELD",
(UnicodeString) "SECOND_FIELD",
(UnicodeString) "MILLISECOND_FIELD",
(UnicodeString) "DAY_OF_WEEK_FIELD",
(UnicodeString) "DAY_OF_YEAR_FIELD",
(UnicodeString) "DAY_OF_WEEK_IN_MONTH_FIELD",
(UnicodeString) "WEEK_OF_YEAR_FIELD",
(UnicodeString) "WEEK_OF_MONTH_FIELD",
(UnicodeString) "AM_PM_FIELD",
(UnicodeString) "HOUR1_FIELD",
(UnicodeString) "HOUR0_FIELD",
(UnicodeString) "TIMEZONE_FIELD"
};
UBool pass = TRUE;
for(int i = 0; i <= 17; ++i) {
FieldPosition pos(i);
UnicodeString buf;
fmt->format(dt, buf, pos);
//char[] dst = new char[pos.getEndIndex() - pos.getBeginIndex()];
UnicodeString dst;
buf.extractBetween(pos.getBeginIndex(), pos.getEndIndex(), dst);
UnicodeString str(dst);
logln((UnicodeString)"" + i + (UnicodeString)": " + fieldNames[i] +
(UnicodeString)", \"" + str + (UnicodeString)"\", " +
pos.getBeginIndex() + (UnicodeString)", " +
pos.getEndIndex());
UnicodeString exp = expected[i];
if((exp.length() == 0 && str.length() == 0) || str == exp)
logln(" ok");
else {
errln(UnicodeString(" expected ") + exp);
pass = FALSE;
}
}
if( ! pass)
errln("Fail: FieldPosition not set right by DateFormat");
delete fmt;
}