static void TestJB4475(){
static const UChar input[][10] = {
{0x0054,0x0045,0x0053,0x0054,0x0000},/* TEST */
{0x0074,0x0065,0x0073,0x0074,0x0000} /* test */
};
int i;
UChar output[40] = {0};
for(i=0; i< sizeof(input)/sizeof(input[0]); i++){
const UChar* src = input[i];
int32_t srcLen = u_strlen(src);
UChar* dest = output;
int32_t destLen = 40;
UErrorCode status = U_ZERO_ERROR;
UParseError ps;
destLen = uidna_toASCII(src, srcLen, dest, destLen,UIDNA_DEFAULT, &ps, &status);
if(U_FAILURE(status)){
log_err_status(status, "uidna_toASCII failed with error %s.\n", u_errorName(status));
continue;
}
if(u_strncmp(input[i], dest, srcLen)!=0){
log_err("uidna_toASCII did not return the expected output.\n");
}
}
}
static void TestDataVariantsCompounds() {
const TransIDSourceTarg* itemsPtr;
for (itemsPtr = dataVarCompItems; itemsPtr->transID != NULL; itemsPtr++) {
UErrorCode status = U_ZERO_ERROR;
UChar utrid[kUBufMax];
int32_t utridlen = u_unescape(itemsPtr->transID, utrid, kUBufMax);
UTransliterator* utrans = utrans_openU(utrid, utridlen, UTRANS_FORWARD, NULL, 0, NULL, &status);
if (U_FAILURE(status)) {
log_data_err("FAIL: utrans_openRules(%s) failed, error=%s (Are you missing data?)\n", itemsPtr->transID, u_errorName(status));
continue;
}
UChar text[kUBufMax];
int32_t textLen = u_unescape(itemsPtr->sourceText, text, kUBufMax);
int32_t textLim = textLen;
utrans_transUChars(utrans, text, &textLen, kUBufMax, 0, &textLim, &status);
if (U_FAILURE(status)) {
log_err("FAIL: utrans_transUChars(%s) failed, error=%s\n", itemsPtr->transID, u_errorName(status));
} else {
UChar expect[kUBufMax];
int32_t expectLen = u_unescape(itemsPtr->targetText, expect, kUBufMax);
if (textLen != expectLen || u_strncmp(text, expect, textLen) != 0) {
char btext[kBBufMax], bexpect[kBBufMax];
u_austrncpy(btext, text, textLen);
u_austrncpy(bexpect, expect, expectLen);
log_err("FAIL: utrans_transUChars(%s),\n expect %s\n get %s\n", itemsPtr->transID, bexpect, btext);
}
}
utrans_close(utrans);
}
}
void TestArabicShapeThreads::doTailTest(void) {
static const UChar src[] = { 0x0020, 0x0633, 0 };
static const UChar dst_old[] = { 0xFEB1, 0x200B,0 };
static const UChar dst_new[] = { 0xFEB1, 0xFE73,0 };
UChar dst[3] = { 0x0000, 0x0000,0 };
int32_t length;
UErrorCode status;
for (int32_t loopCount = 0; loopCount < 100; loopCount++) {
status = U_ZERO_ERROR;
length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR, &status);
if(U_FAILURE(status)) {
IntlTest::gTest->errln("Fail: status %s\n", u_errorName(status));
return;
} else if(length!=2) {
IntlTest::gTest->errln("Fail: len %d expected 3\n", length);
return;
} else if(u_strncmp(dst,dst_old,UPRV_LENGTHOF(dst))) {
IntlTest::gTest->errln("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
dst[0],dst[1],dst_old[0],dst_old[1]);
return;
}
//"Trying new tail
status = U_ZERO_ERROR;
length = u_shapeArabic(src, -1, dst, UPRV_LENGTHOF(dst),
U_SHAPE_LETTERS_SHAPE|U_SHAPE_SEEN_TWOCELL_NEAR|U_SHAPE_TAIL_NEW_UNICODE, &status);
if(U_FAILURE(status)) {
IntlTest::gTest->errln("Fail: status %s\n", u_errorName(status));
return;
} else if(length!=2) {
IntlTest::gTest->errln("Fail: len %d expected 3\n", length);
return;
} else if(u_strncmp(dst,dst_new,UPRV_LENGTHOF(dst))) {
IntlTest::gTest->errln("Fail: got U+%04X U+%04X expected U+%04X U+%04X\n",
dst[0],dst[1],dst_new[0],dst_new[1]);
return;
}
}
return;
}
static void TestCombineDateTime()
{
const CombineDateTimeTestItem *itemPtr;
log_verbose("\nTesting ureldatefmt_combineDateAndTime() with various parameters\n");
for (itemPtr = combTestItems; itemPtr->locale != NULL; itemPtr++) {
URelativeDateTimeFormatter *reldatefmt = NULL;
UErrorCode status = U_ZERO_ERROR;
UChar ubufreldate[kUBufMax];
UChar ubuftime[kUBufMax];
UChar ubufget[kUBufMax];
int32_t ulenreldate, ulentime, ulenget;
reldatefmt = ureldatefmt_open(itemPtr->locale, NULL, itemPtr->width, itemPtr->capContext, &status);
if ( U_FAILURE(status) ) {
log_data_err("FAIL: ureldatefmt_open() for locale %s, width %d, capContext %d: %s\n",
itemPtr->locale, (int)itemPtr->width, (int)itemPtr->capContext, myErrorName(status) );
continue;
}
ulenreldate = u_unescape(itemPtr->relativeDateString, ubufreldate, kUBufMax);
ulentime = u_unescape(itemPtr->timeString, ubuftime, kUBufMax);
ulenget = ureldatefmt_combineDateAndTime(reldatefmt, ubufreldate, ulenreldate, ubuftime, ulentime, ubufget, kUBufMax, &status);
if ( U_FAILURE(status) ) {
log_err("FAIL: ureldatefmt_combineDateAndTime() for locale %s, width %d, capContext %d: %s\n",
itemPtr->locale, (int)itemPtr->width, (int)itemPtr->capContext, myErrorName(status) );
} else {
UChar ubufexp[kUBufMax];
int32_t ulenexp = u_unescape(itemPtr->expectedResult, ubufexp, kUBufMax);
if (ulenget != ulenexp || u_strncmp(ubufget, ubufexp, ulenexp) != 0) {
char bbufget[kBBufMax];
u_austrncpy(bbufget, ubufget, kUBufMax);
log_err("ERROR: ureldatefmt_combineDateAndTime() for locale %s, width %d, capContext %d;\n expected %s\n get %s\n",
itemPtr->locale, (int)itemPtr->width, (int)itemPtr->capContext, itemPtr->expectedResult, bbufget );
}
}
// preflight test
status = U_ZERO_ERROR;
ulenget = ureldatefmt_combineDateAndTime(reldatefmt, ubufreldate, ulenreldate, ubuftime, ulentime, NULL, 0, &status);
if ( status != U_BUFFER_OVERFLOW_ERROR) {
log_err("FAIL: ureldatefmt_combineDateAndTime() preflight for locale %s, width %d, capContext %d: expected U_BUFFER_OVERFLOW_ERROR, got %s\n",
itemPtr->locale, (int)itemPtr->width, (int)itemPtr->capContext, myErrorName(status) );
} else {
UChar ubufexp[kUBufMax];
int32_t ulenexp = u_unescape(itemPtr->expectedResult, ubufexp, kUBufMax);
if (ulenget != ulenexp) {
log_err("ERROR: ureldatefmt_combineDateAndTime() preflight for locale %s, width %d, capContext %d;\n expected len %d, get len %d\n",
itemPtr->locale, (int)itemPtr->width, (int)itemPtr->capContext, ulenexp, ulenget );
}
}
ureldatefmt_close(reldatefmt);
}
}
void TestQuotePattern161()
{
UDateFormat *format;
UCalendar *cal;
UDate currentTime_1;
UChar *pattern, *tzID, *exp;
UChar *dateString;
UErrorCode status = U_ZERO_ERROR;
const char* expStr = "04/13/1999 at 10:42:28 AM ";
ctest_setTimeZone(NULL, &status);
pattern=(UChar*)malloc(sizeof(UChar) * (strlen("MM/dd/yyyy 'at' hh:mm:ss a zzz")+1) );
u_uastrcpy(pattern, "MM/dd/yyyy 'at' hh:mm:ss a zzz");
/* this is supposed to open default date format, but later on it treats it like it is "en_US"
- very bad if you try to run the tests on machine where default locale is NOT "en_US" */
/* format= udat_openPattern(pattern, u_strlen(pattern), NULL, &status); */
format= udat_open(UDAT_IGNORE, UDAT_IGNORE,"en_US", NULL, 0,pattern, u_strlen(pattern), &status);
if(U_FAILURE(status)){
log_err_status(status, "error in udat_open: %s\n", myErrorName(status));
return;
}
tzID=(UChar*)malloc(sizeof(UChar) * 4);
u_uastrcpy(tzID, "PST");
/* this is supposed to open default date format, but later on it treats it like it is "en_US"
- very bad if you try to run the tests on machine where default locale is NOT "en_US" */
/* cal=ucal_open(tzID, u_strlen(tzID), NULL, UCAL_TRADITIONAL, &status); */
cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
if(U_FAILURE(status)){ log_err("error in ucal_open cal : %s\n", myErrorName(status)); }
ucal_setDateTime(cal, 1999, UCAL_APRIL, 13, 10, 42, 28, &status);
currentTime_1 = ucal_getMillis(cal, &status);
dateString = myDateFormat(format, currentTime_1);
exp=(UChar*)malloc(sizeof(UChar) * (strlen(expStr) + 1) );
u_uastrcpy(exp, expStr);
log_verbose("%s\n", austrdup(dateString) );
if(u_strncmp(dateString, exp, (int32_t)strlen(expStr)) !=0)
log_err("Error in formatting a pattern with single quotes\n");
udat_close(format);
ucal_close(cal);
free(exp);
free(tzID);
free(pattern);
ctest_resetTimeZone();
}
static void TestOptions() {
const DTPtnGenOptionsData testData[] = {
/*loc skel options expectedPattern */
{ "en", skel_Hmm, UDATPG_MATCH_NO_OPTIONS, patn_HHcmm },
{ "en", skel_HHmm, UDATPG_MATCH_NO_OPTIONS, patn_HHcmm },
{ "en", skel_hhmm, UDATPG_MATCH_NO_OPTIONS, patn_hcmm_a },
{ "en", skel_Hmm, UDATPG_MATCH_HOUR_FIELD_LENGTH, patn_HHcmm },
{ "en", skel_HHmm, UDATPG_MATCH_HOUR_FIELD_LENGTH, patn_HHcmm },
{ "en", skel_hhmm, UDATPG_MATCH_HOUR_FIELD_LENGTH, patn_hhcmm_a },
{ "be", skel_Hmm, UDATPG_MATCH_NO_OPTIONS, patn_HHpmm },
{ "be", skel_HHmm, UDATPG_MATCH_NO_OPTIONS, patn_HHpmm },
{ "be", skel_hhmm, UDATPG_MATCH_NO_OPTIONS, patn_hpmm_a },
{ "be", skel_Hmm, UDATPG_MATCH_HOUR_FIELD_LENGTH, patn_Hpmm },
{ "be", skel_HHmm, UDATPG_MATCH_HOUR_FIELD_LENGTH, patn_HHpmm },
{ "be", skel_hhmm, UDATPG_MATCH_HOUR_FIELD_LENGTH, patn_hhpmm_a },
};
int count = sizeof(testData) / sizeof(testData[0]);
const DTPtnGenOptionsData * testDataPtr = testData;
for (; count-- > 0; ++testDataPtr) {
UErrorCode status = U_ZERO_ERROR;
UDateTimePatternGenerator * dtpgen = udatpg_open(testDataPtr->locale, &status);
if ( U_SUCCESS(status) ) {
UChar pattern[kTestOptionsPatLenMax];
int32_t patLen = udatpg_getBestPatternWithOptions(dtpgen, testDataPtr->skel, -1,
testDataPtr->options, pattern,
kTestOptionsPatLenMax, &status);
if ( U_FAILURE(status) || u_strncmp(pattern, testDataPtr->expectedPattern, patLen+1) != 0 ) {
char skelBytes[kTestOptionsPatLenMax];
char expectedPatternBytes[kTestOptionsPatLenMax];
char patternBytes[kTestOptionsPatLenMax];
log_err("ERROR udatpg_getBestPatternWithOptions, locale %s, skeleton %s, options 0x%04X, expected pattern %s, got %s, status %d\n",
testDataPtr->locale, u_austrncpy(skelBytes,testDataPtr->skel,kTestOptionsPatLenMax), testDataPtr->options,
u_austrncpy(expectedPatternBytes,testDataPtr->expectedPattern,kTestOptionsPatLenMax),
u_austrncpy(patternBytes,pattern,kTestOptionsPatLenMax), status );
}
udatpg_close(dtpgen);
} else {
log_data_err("ERROR udatpg_open failed for locale %s : %s - (Are you missing data?)\n", testDataPtr->locale, myErrorName(status));
}
}
}
static void TestFPos_SkelWithSeconds()
{
const LocaleAndSkeletonItem * locSkelItemPtr;
for (locSkelItemPtr = locSkelItems; locSkelItemPtr->locale != NULL; locSkelItemPtr++) {
UDateIntervalFormat* udifmt;
UChar ubuf[kSizeUBuf];
int32_t ulen, uelen;
UErrorCode status = U_ZERO_ERROR;
u_strFromUTF8(ubuf, kSizeUBuf, &ulen, locSkelItemPtr->skeleton, -1, &status);
udifmt = udtitvfmt_open(locSkelItemPtr->locale, ubuf, ulen, zoneGMT, -1, &status);
if ( U_FAILURE(status) ) {
log_data_err("FAIL: udtitvfmt_open for locale %s, skeleton %s: %s\n",
locSkelItemPtr->locale, locSkelItemPtr->skeleton, u_errorName(status));
} else {
const double * deltasPtr = deltas;
const ExpectPosAndFormat * expectedPtr = locSkelItemPtr->expected;
for (; *deltasPtr >= 0.0; deltasPtr++, expectedPtr++) {
UFieldPosition fpos = { locSkelItemPtr->fieldToCheck, 0, 0 };
UChar uebuf[kSizeUBuf];
char bbuf[kSizeBBuf];
char bebuf[kSizeBBuf];
status = U_ZERO_ERROR;
uelen = u_unescape(expectedPtr->format, uebuf, kSizeUBuf);
ulen = udtitvfmt_format(udifmt, startTime, startTime + *deltasPtr, ubuf, kSizeUBuf, &fpos, &status);
if ( U_FAILURE(status) ) {
log_err("FAIL: udtitvfmt_format for locale %s, skeleton %s, delta %.1f: %s\n",
locSkelItemPtr->locale, locSkelItemPtr->skeleton, *deltasPtr, u_errorName(status));
} else if ( ulen != uelen || u_strncmp(ubuf,uebuf,uelen) != 0 ||
fpos.beginIndex != expectedPtr->posBegin || fpos.endIndex != expectedPtr->posEnd ) {
u_strToUTF8(bbuf, kSizeBBuf, NULL, ubuf, ulen, &status);
u_strToUTF8(bebuf, kSizeBBuf, NULL, uebuf, uelen, &status); // convert back to get unescaped string
log_err("FAIL: udtitvfmt_format for locale %s, skeleton %s, delta %12.1f, expect %d-%d \"%s\", get %d-%d \"%s\"\n",
locSkelItemPtr->locale, locSkelItemPtr->skeleton, *deltasPtr,
expectedPtr->posBegin, expectedPtr->posEnd, bebuf,
fpos.beginIndex, fpos.endIndex, bbuf);
}
}
udtitvfmt_close(udifmt);
}
}
}
void RelativeDateFormat::loadDates(UErrorCode &status) {
UResourceBundle *rb = ures_open(NULL, fLocale.getBaseName(), &status);
LocalUResourceBundlePointer dateTimePatterns(
ures_getByKeyWithFallback(rb,
"calendar/gregorian/DateTimePatterns",
(UResourceBundle*)NULL, &status));
if(U_SUCCESS(status)) {
int32_t patternsSize = ures_getSize(dateTimePatterns.getAlias());
if (patternsSize > kDateTime) {
int32_t resStrLen = 0;
int32_t glueIndex = kDateTime;
if (patternsSize >= (kDateTimeOffset + kShort + 1)) {
int32_t offsetIncrement = (fDateStyle & ~kRelative); // Remove relative bit.
if (offsetIncrement >= (int32_t)kFull &&
offsetIncrement <= (int32_t)kShortRelative) {
glueIndex = kDateTimeOffset + offsetIncrement;
}
}
const UChar *resStr = ures_getStringByIndex(dateTimePatterns.getAlias(), glueIndex, &resStrLen, &status);
if (U_SUCCESS(status) && resStrLen >= patItem1Len && u_strncmp(resStr,patItem1,patItem1Len)==0) {
fCombinedHasDateAtStart = TRUE;
}
fCombinedFormat = new SimpleFormatter(UnicodeString(TRUE, resStr, resStrLen), 2, 2, status);
}
}
// Data loading for relative names, e.g., "yesterday", "today", "tomorrow".
fDatesLen = UDAT_DIRECTION_COUNT; // Maximum defined by data.
fDates = (URelativeString*) uprv_malloc(sizeof(fDates[0])*fDatesLen);
RelDateFmtDataSink sink(fDates, fDatesLen);
ures_getAllItemsWithFallback(rb, "fields/day/relative", sink, status);
ures_close(rb);
if(U_FAILURE(status)) {
fDatesLen=0;
return;
}
}
/*----------------------------------------------------------------------------------------------
Do a direct string comparison.
----------------------------------------------------------------------------------------------*/
STDMETHODIMP LgUnicodeCollater::Compare(BSTR bstrValue1, BSTR bstrValue2,
LgCollatingOptions colopt, int * pnVal)
{
BEGIN_COM_METHOD
ChkComBstrArg(bstrValue1);
ChkComBstrArg(bstrValue2);
ChkComOutPtr(pnVal);
HRESULT hr;
int cchw1;
int cchw2;
IgnoreHr(hr = SortKeyRgch(bstrValue1, BstrLen(bstrValue1), colopt, 0, NULL, &cchw1));
if (FAILED(hr))
return hr;
IgnoreHr(hr = SortKeyRgch(bstrValue2, BstrLen(bstrValue2), colopt, 0, NULL, &cchw2));
if (FAILED(hr))
return hr;
OLECHAR * pchKey1 = (OLECHAR *) _alloca(cchw1 * isizeof(OLECHAR));
OLECHAR * pchKey2 = (OLECHAR *) _alloca(cchw2 * isizeof(OLECHAR));
IgnoreHr(hr = SortKeyRgch(bstrValue1, BstrLen(bstrValue1), colopt, cchw1, pchKey1, &cchw1));
if (FAILED(hr))
return hr;
IgnoreHr(hr = SortKeyRgch(bstrValue2, BstrLen(bstrValue2), colopt, cchw2, pchKey2, &cchw2));
if (FAILED(hr))
return hr;
int nVal = u_strncmp(pchKey1, pchKey2, min(cchw1, cchw2));
if (!nVal)
{
// equal as far as length of shortest key
if (BstrLen(bstrValue1) < BstrLen(bstrValue2))
nVal = -1;
else if (BstrLen(bstrValue1) > BstrLen(bstrValue2))
nVal = 1;
}
*pnVal = nVal;
END_COM_METHOD(g_fact, IID_ILgCollatingEngine);
}
static void TestRelDateFmt()
{
const RelDateTimeFormatTestItem *itemPtr;
log_verbose("\nTesting ureldatefmt_open(), ureldatefmt_format(), ureldatefmt_formatNumeric() with various parameters\n");
for (itemPtr = fmtTestItems; itemPtr->locale != NULL; itemPtr++) {
URelativeDateTimeFormatter *reldatefmt = NULL;
UNumberFormat* nfToAdopt = NULL;
UErrorCode status = U_ZERO_ERROR;
int32_t iOffset;
if (itemPtr->decPlaces >= 0) {
nfToAdopt = unum_open(UNUM_DECIMAL, NULL, 0, itemPtr->locale, NULL, &status);
if ( U_FAILURE(status) ) {
log_data_err("FAIL: unum_open(UNUM_DECIMAL, ...) for locale %s: %s\n", itemPtr->locale, myErrorName(status));
continue;
}
unum_setAttribute(nfToAdopt, UNUM_MIN_FRACTION_DIGITS, itemPtr->decPlaces);
unum_setAttribute(nfToAdopt, UNUM_MAX_FRACTION_DIGITS, itemPtr->decPlaces);
unum_setAttribute(nfToAdopt, UNUM_ROUNDING_MODE, UNUM_ROUND_DOWN);
}
reldatefmt = ureldatefmt_open(itemPtr->locale, nfToAdopt, itemPtr->width, itemPtr->capContext, &status);
if ( U_FAILURE(status) ) {
log_data_err("FAIL: ureldatefmt_open() for locale %s, decPlaces %d, width %d, capContext %d: %s\n",
itemPtr->locale, itemPtr->decPlaces, (int)itemPtr->width, (int)itemPtr->capContext,
myErrorName(status) );
continue;
}
for (iOffset = 0; iOffset < kNumOffsets; iOffset++) {
UChar ubufget[kUBufMax];
int32_t ulenget;
if (itemPtr->unit >= UDAT_REL_UNIT_SUNDAY && offsets[iOffset] != -1.0 && offsets[iOffset] != 0.0 && offsets[iOffset] != 1.0) {
continue; /* we do not currently have data for this */
}
status = U_ZERO_ERROR;
ulenget = ureldatefmt_format(reldatefmt, offsets[iOffset], itemPtr->unit, ubufget, kUBufMax, &status);
if ( U_FAILURE(status) ) {
log_err("FAIL: ureldatefmt_format() for locale %s, decPlaces %d, width %d, capContext %d, offset %.2f, unit %d: %s\n",
itemPtr->locale, itemPtr->decPlaces, (int)itemPtr->width, (int)itemPtr->capContext,
offsets[iOffset], (int)itemPtr->unit, myErrorName(status) );
} else {
UChar ubufexp[kUBufMax];
int32_t ulenexp = u_unescape(itemPtr->expectedResults[iOffset*2], ubufexp, kUBufMax);
if (ulenget != ulenexp || u_strncmp(ubufget, ubufexp, ulenexp) != 0) {
char bbufget[kBBufMax];
u_austrncpy(bbufget, ubufget, kUBufMax);
log_err("ERROR: ureldatefmt_format() for locale %s, decPlaces %d, width %d, capContext %d, offset %.2f, unit %d;\n expected %s\n get %s\n",
itemPtr->locale, itemPtr->decPlaces, (int)itemPtr->width, (int)itemPtr->capContext,
offsets[iOffset], (int)itemPtr->unit, itemPtr->expectedResults[iOffset*2], bbufget );
}
}
if (itemPtr->unit >= UDAT_REL_UNIT_SUNDAY) {
continue; /* we do not currently have numeric-style data for this */
}
status = U_ZERO_ERROR;
ulenget = ureldatefmt_formatNumeric(reldatefmt, offsets[iOffset], itemPtr->unit, ubufget, kUBufMax, &status);
if ( U_FAILURE(status) ) {
log_err("FAIL: ureldatefmt_formatNumeric() for locale %s, decPlaces %d, width %d, capContext %d, offset %.2f, unit %d: %s\n",
itemPtr->locale, itemPtr->decPlaces, (int)itemPtr->width, (int)itemPtr->capContext,
offsets[iOffset], (int)itemPtr->unit, myErrorName(status) );
} else {
UChar ubufexp[kUBufMax];
int32_t ulenexp = u_unescape(itemPtr->expectedResults[iOffset*2 + 1], ubufexp, kUBufMax);
if (ulenget != ulenexp || u_strncmp(ubufget, ubufexp, ulenexp) != 0) {
char bbufget[kBBufMax];
u_austrncpy(bbufget, ubufget, kUBufMax);
log_err("ERROR: ureldatefmt_formatNumeric() for locale %s, decPlaces %d, width %d, capContext %d, offset %.2f, unit %d;\n expected %s\n get %s\n",
itemPtr->locale, itemPtr->decPlaces, (int)itemPtr->width, (int)itemPtr->capContext,
offsets[iOffset], (int)itemPtr->unit, itemPtr->expectedResults[iOffset*2 + 1], bbufget );
}
}
}
ureldatefmt_close(reldatefmt);
}
}
/* Instead of having a separate pass for 'special' patterns, reintegrate the two
* so we don't get bitten by preflight bugs again. We can be reasonably efficient
* without two separate code paths, this code isn't that performance-critical.
*
* This code is general enough to deal with patterns that have a prefix or swap the
* language and remainder components, since we gave developers enough rope to do such
* things if they futz with the pattern data. But since we don't give them a way to
* specify a pattern for arbitrary combinations of components, there's not much use in
* that. I don't think our data includes such patterns, the only variable I know if is
* whether there is a space before the open paren, or not. Oh, and zh uses different
* chars than the standard open/close paren (which ja and ko use, btw).
*/
U_CAPI int32_t U_EXPORT2
uloc_getDisplayName(const char *locale,
const char *displayLocale,
UChar *dest, int32_t destCapacity,
UErrorCode *pErrorCode)
{
static const UChar defaultSeparator[9] = { 0x007b, 0x0030, 0x007d, 0x002c, 0x0020, 0x007b, 0x0031, 0x007d, 0x0000 }; /* "{0}, {1}" */
static const UChar sub0[4] = { 0x007b, 0x0030, 0x007d , 0x0000 } ; /* {0} */
static const UChar sub1[4] = { 0x007b, 0x0031, 0x007d , 0x0000 } ; /* {1} */
static const int32_t subLen = 3;
static const UChar defaultPattern[10] = {
0x007b, 0x0030, 0x007d, 0x0020, 0x0028, 0x007b, 0x0031, 0x007d, 0x0029, 0x0000
}; /* {0} ({1}) */
static const int32_t defaultPatLen = 9;
static const int32_t defaultSub0Pos = 0;
static const int32_t defaultSub1Pos = 5;
int32_t length; /* of formatted result */
const UChar *separator;
int32_t sepLen = 0;
const UChar *pattern;
int32_t patLen = 0;
int32_t sub0Pos, sub1Pos;
UChar formatOpenParen = 0x0028; // (
UChar formatReplaceOpenParen = 0x005B; // [
UChar formatCloseParen = 0x0029; // )
UChar formatReplaceCloseParen = 0x005D; // ]
UBool haveLang = TRUE; /* assume true, set false if we find we don't have
a lang component in the locale */
UBool haveRest = TRUE; /* assume true, set false if we find we don't have
any other component in the locale */
UBool retry = FALSE; /* set true if we need to retry, see below */
int32_t langi = 0; /* index of the language substitution (0 or 1), virtually always 0 */
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
return 0;
}
if(destCapacity<0 || (destCapacity>0 && dest==NULL)) {
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
{
UErrorCode status = U_ZERO_ERROR;
UResourceBundle* locbundle=ures_open(U_ICUDATA_LANG, displayLocale, &status);
UResourceBundle* dspbundle=ures_getByKeyWithFallback(locbundle, _kLocaleDisplayPattern,
NULL, &status);
separator=ures_getStringByKeyWithFallback(dspbundle, _kSeparator, &sepLen, &status);
pattern=ures_getStringByKeyWithFallback(dspbundle, _kPattern, &patLen, &status);
ures_close(dspbundle);
ures_close(locbundle);
}
/* If we couldn't find any data, then use the defaults */
if(sepLen == 0) {
separator = defaultSeparator;
}
/* #10244: Even though separator is now a pattern, it is awkward to handle it as such
* here since we are trying to build the display string in place in the dest buffer,
* and to handle it as a pattern would entail having separate storage for the
* substrings that need to be combined (the first of which may be the result of
* previous such combinations). So for now we continue to treat the portion between
* {0} and {1} as a string to be appended when joining substrings, ignoring anything
* that is before {0} or after {1} (no existing separator pattern has any such thing).
* This is similar to how pattern is handled below.
*/
{
UChar *p0=u_strstr(separator, sub0);
UChar *p1=u_strstr(separator, sub1);
if (p0==NULL || p1==NULL || p1<p0) {
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
separator = (const UChar *)p0 + subLen;
sepLen = p1 - separator;
}
if(patLen==0 || (patLen==defaultPatLen && !u_strncmp(pattern, defaultPattern, patLen))) {
pattern=defaultPattern;
patLen=defaultPatLen;
sub0Pos=defaultSub0Pos;
sub1Pos=defaultSub1Pos;
// use default formatOpenParen etc. set above
} else { /* non-default pattern */
UChar *p0=u_strstr(pattern, sub0);
UChar *p1=u_strstr(pattern, sub1);
if (p0==NULL || p1==NULL) {
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
sub0Pos=p0-pattern;
sub1Pos=p1-pattern;
if (sub1Pos < sub0Pos) { /* a very odd pattern */
int32_t t=sub0Pos; sub0Pos=sub1Pos; sub1Pos=t;
langi=1;
}
if (u_strchr(pattern, 0xFF08) != NULL) {
formatOpenParen = 0xFF08; // fullwidth (
formatReplaceOpenParen = 0xFF3B; // fullwidth [
formatCloseParen = 0xFF09; // fullwidth )
formatReplaceCloseParen = 0xFF3D; // fullwidth ]
}
}
/* We loop here because there is one case in which after the first pass we could need to
* reextract the data. If there's initial padding before the first element, we put in
* the padding and then write that element. If it turns out there's no second element,
* we didn't need the padding. If we do need the data (no preflight), and the first element
* would have fit but for the padding, we need to reextract. In this case (only) we
* adjust the parameters so padding is not added, and repeat.
*/
do {
UChar* p=dest;
int32_t patPos=0; /* position in the pattern, used for non-substitution portions */
int32_t langLen=0; /* length of language substitution */
int32_t langPos=0; /* position in output of language substitution */
int32_t restLen=0; /* length of 'everything else' substitution */
int32_t restPos=0; /* position in output of 'everything else' substitution */
UEnumeration* kenum = NULL; /* keyword enumeration */
/* prefix of pattern, extremely likely to be empty */
if(sub0Pos) {
if(destCapacity >= sub0Pos) {
while (patPos < sub0Pos) {
*p++ = pattern[patPos++];
}
} else {
patPos=sub0Pos;
}
length=sub0Pos;
} else {
length=0;
}
for(int32_t subi=0,resti=0;subi<2;) { /* iterate through patterns 0 and 1*/
UBool subdone = FALSE; /* set true when ready to move to next substitution */
/* prep p and cap for calls to get display components, pin cap to 0 since
they complain if cap is negative */
int32_t cap=destCapacity-length;
if (cap <= 0) {
cap=0;
} else {
p=dest+length;
}
if (subi == langi) { /* {0}*/
if(haveLang) {
langPos=length;
langLen=uloc_getDisplayLanguage(locale, displayLocale, p, cap, pErrorCode);
length+=langLen;
haveLang=langLen>0;
}
subdone=TRUE;
} else { /* {1} */
if(!haveRest) {
subdone=TRUE;
} else {
int32_t len; /* length of component (plus other stuff) we just fetched */
switch(resti++) {
case 0:
restPos=length;
len=uloc_getDisplayScriptInContext(locale, displayLocale, p, cap, pErrorCode);
break;
case 1:
len=uloc_getDisplayCountry(locale, displayLocale, p, cap, pErrorCode);
break;
case 2:
len=uloc_getDisplayVariant(locale, displayLocale, p, cap, pErrorCode);
break;
case 3:
kenum = uloc_openKeywords(locale, pErrorCode);
/* fall through */
default: {
const char* kw=uenum_next(kenum, &len, pErrorCode);
if (kw == NULL) {
uenum_close(kenum);
len=0; /* mark that we didn't add a component */
subdone=TRUE;
} else {
/* incorporating this behavior into the loop made it even more complex,
so just special case it here */
len = uloc_getDisplayKeyword(kw, displayLocale, p, cap, pErrorCode);
if(len) {
if(len < cap) {
p[len]=0x3d; /* '=', assume we'll need it */
}
len+=1;
/* adjust for call to get keyword */
cap-=len;
if(cap <= 0) {
cap=0;
} else {
p+=len;
}
}
/* reset for call below */
if(*pErrorCode == U_BUFFER_OVERFLOW_ERROR) {
*pErrorCode=U_ZERO_ERROR;
}
int32_t vlen = uloc_getDisplayKeywordValue(locale, kw, displayLocale,
p, cap, pErrorCode);
if(len) {
if(vlen==0) {
--len; /* remove unneeded '=' */
}
/* restore cap and p to what they were at start */
cap=destCapacity-length;
if(cap <= 0) {
cap=0;
} else {
p=dest+length;
}
}
len+=vlen; /* total we added for key + '=' + value */
}
} break;
} /* end switch */
if (len>0) {
/* we addeed a component, so add separator and write it if there's room. */
if(len+sepLen<=cap) {
const UChar * plimit = p + len;
for (; p < plimit; p++) {
if (*p == formatOpenParen) {
*p = formatReplaceOpenParen;
} else if (*p == formatCloseParen) {
*p = formatReplaceCloseParen;
}
}
for(int32_t i=0;i<sepLen;++i) {
*p++=separator[i];
}
}
length+=len+sepLen;
} else if(subdone) {
/* remove separator if we added it */
if (length!=restPos) {
length-=sepLen;
}
restLen=length-restPos;
haveRest=restLen>0;
}
}
}
if(*pErrorCode == U_BUFFER_OVERFLOW_ERROR) {
*pErrorCode=U_ZERO_ERROR;
}
if(subdone) {
if(haveLang && haveRest) {
/* append internal portion of pattern, the first time,
or last portion of pattern the second time */
int32_t padLen;
patPos+=subLen;
padLen=(subi==0 ? sub1Pos : patLen)-patPos;
if(length+padLen < destCapacity) {
p=dest+length;
for(int32_t i=0;i<padLen;++i) {
*p++=pattern[patPos++];
}
} else {
patPos+=padLen;
}
length+=padLen;
} else if(subi==0) {
/* don't have first component, reset for second component */
sub0Pos=0;
length=0;
} else if(length>0) {
/* true length is the length of just the component we got. */
length=haveLang?langLen:restLen;
if(dest && sub0Pos!=0) {
if (sub0Pos+length<=destCapacity) {
/* first component not at start of result,
but we have full component in buffer. */
u_memmove(dest, dest+(haveLang?langPos:restPos), length);
} else {
/* would have fit, but didn't because of pattern prefix. */
sub0Pos=0; /* stops initial padding (and a second retry,
so we won't end up here again) */
retry=TRUE;
}
}
}
++subi; /* move on to next substitution */
}
}
} while(retry);
return u_terminateUChars(dest, destCapacity, length, pErrorCode);
}
static void TestUListFmt() {
const ListFmtTestEntry * lftep;
for (lftep = listFmtTestEntries; lftep->locale != NULL ; lftep++ ) {
UErrorCode status = U_ZERO_ERROR;
UListFormatter *listfmt = ulistfmt_open(lftep->locale, &status);
if ( U_FAILURE(status) ) {
log_data_err("ERROR: ulistfmt_open fails for locale %s, status %s\n", lftep->locale, u_errorName(status));
} else {
UChar ubufActual[kUBufMax];
int32_t ulenActual = ulistfmt_format(listfmt, strings, stringLengths, lftep->stringCount, ubufActual, kUBufMax, &status);
if ( U_FAILURE(status) ) {
log_err("ERROR: ulistfmt_format fails for locale %s count %d (real lengths), status %s\n", lftep->locale, lftep->stringCount, u_errorName(status));
} else {
UChar ubufExpected[kUBufMax];
int32_t ulenExpected = u_unescape(lftep->expectedResult, ubufExpected, kUBufMax);
if (ulenActual != ulenExpected || u_strncmp(ubufActual, ubufExpected, ulenExpected) != 0) {
log_err("ERROR: ulistfmt_format for locale %s count %d (real lengths), actual \"%s\" != expected \"%s\"\n", lftep->locale,
lftep->stringCount, aescstrdup(ubufActual, ulenActual), aescstrdup(ubufExpected, ulenExpected));
}
}
/* try again with all lengths -1 */
status = U_ZERO_ERROR;
ulenActual = ulistfmt_format(listfmt, strings, stringLengthsNeg, lftep->stringCount, ubufActual, kUBufMax, &status);
if ( U_FAILURE(status) ) {
log_err("ERROR: ulistfmt_format fails for locale %s count %d (-1 lengths), status %s\n", lftep->locale, lftep->stringCount, u_errorName(status));
} else {
UChar ubufExpected[kUBufMax];
int32_t ulenExpected = u_unescape(lftep->expectedResult, ubufExpected, kUBufMax);
if (ulenActual != ulenExpected || u_strncmp(ubufActual, ubufExpected, ulenExpected) != 0) {
log_err("ERROR: ulistfmt_format for locale %s count %d (-1 lengths), actual \"%s\" != expected \"%s\"\n", lftep->locale,
lftep->stringCount, aescstrdup(ubufActual, ulenActual), aescstrdup(ubufExpected, ulenExpected));
}
}
/* try again with NULL lengths */
status = U_ZERO_ERROR;
ulenActual = ulistfmt_format(listfmt, strings, NULL, lftep->stringCount, ubufActual, kUBufMax, &status);
if ( U_FAILURE(status) ) {
log_err("ERROR: ulistfmt_format fails for locale %s count %d (NULL lengths), status %s\n", lftep->locale, lftep->stringCount, u_errorName(status));
} else {
UChar ubufExpected[kUBufMax];
int32_t ulenExpected = u_unescape(lftep->expectedResult, ubufExpected, kUBufMax);
if (ulenActual != ulenExpected || u_strncmp(ubufActual, ubufExpected, ulenExpected) != 0) {
log_err("ERROR: ulistfmt_format for locale %s count %d (NULL lengths), actual \"%s\" != expected \"%s\"\n", lftep->locale,
lftep->stringCount, aescstrdup(ubufActual, ulenActual), aescstrdup(ubufExpected, ulenExpected));
}
}
/* try calls that should return error */
status = U_ZERO_ERROR;
ulenActual = ulistfmt_format(listfmt, NULL, NULL, lftep->stringCount, ubufActual, kUBufMax, &status);
if (status != U_ILLEGAL_ARGUMENT_ERROR || ulenActual > 0) {
log_err("ERROR: ulistfmt_format for locale %s count %d with NULL strings, expected U_ILLEGAL_ARGUMENT_ERROR, got %s, result %d\n", lftep->locale,
lftep->stringCount, u_errorName(status), ulenActual);
}
status = U_ZERO_ERROR;
ulenActual = ulistfmt_format(listfmt, strings, NULL, lftep->stringCount, NULL, kUBufMax, &status);
if (status != U_ILLEGAL_ARGUMENT_ERROR || ulenActual > 0) {
log_err("ERROR: ulistfmt_format for locale %s count %d with NULL result, expected U_ILLEGAL_ARGUMENT_ERROR, got %s, result %d\n", lftep->locale,
lftep->stringCount, u_errorName(status), ulenActual);
}
ulistfmt_close(listfmt);
}
}
}
void RelativeDateFormat::loadDates(UErrorCode &status) {
CalendarData calData(fLocale, "gregorian", status);
UErrorCode tempStatus = status;
UResourceBundle *dateTimePatterns = calData.getByKey(DT_DateTimePatternsTag, tempStatus);
if(U_SUCCESS(tempStatus)) {
int32_t patternsSize = ures_getSize(dateTimePatterns);
if (patternsSize > kDateTime) {
int32_t resStrLen = 0;
int32_t glueIndex = kDateTime;
if (patternsSize >= (DateFormat::kDateTimeOffset + DateFormat::kShort + 1)) {
// Get proper date time format
switch (fDateStyle) {
case kFullRelative:
case kFull:
glueIndex = kDateTimeOffset + kFull;
break;
case kLongRelative:
case kLong:
glueIndex = kDateTimeOffset + kLong;
break;
case kMediumRelative:
case kMedium:
glueIndex = kDateTimeOffset + kMedium;
break;
case kShortRelative:
case kShort:
glueIndex = kDateTimeOffset + kShort;
break;
default:
break;
}
}
const UChar *resStr = ures_getStringByIndex(dateTimePatterns, glueIndex, &resStrLen, &tempStatus);
if (U_SUCCESS(tempStatus) && resStrLen >= patItem1Len && u_strncmp(resStr,patItem1,patItem1Len)==0) {
fCombinedHasDateAtStart = TRUE;
}
fCombinedFormat = new SimpleFormatter(UnicodeString(TRUE, resStr, resStrLen), 2, 2, tempStatus);
}
}
UResourceBundle *rb = ures_open(NULL, fLocale.getBaseName(), &status);
rb = ures_getByKeyWithFallback(rb, "fields", rb, &status);
rb = ures_getByKeyWithFallback(rb, "day", rb, &status);
rb = ures_getByKeyWithFallback(rb, "relative", rb, &status);
// set up min/max
fDayMin=-1;
fDayMax=1;
if(U_FAILURE(status)) {
fDatesLen=0;
ures_close(rb);
return;
}
fDatesLen = ures_getSize(rb);
fDates = (URelativeString*) uprv_malloc(sizeof(fDates[0])*fDatesLen);
// Load in each item into the array...
int n = 0;
UResourceBundle *subString = NULL;
while(ures_hasNext(rb) && U_SUCCESS(status)) { // iterate over items
subString = ures_getNextResource(rb, subString, &status);
if(U_FAILURE(status) || (subString==NULL)) break;
// key = offset #
const char *key = ures_getKey(subString);
// load the string and length
int32_t aLen;
const UChar* aString = ures_getString(subString, &aLen, &status);
if(U_FAILURE(status) || aString == NULL) break;
// calculate the offset
int32_t offset = atoi(key);
// set min/max
if(offset < fDayMin) {
fDayMin = offset;
}
if(offset > fDayMax) {
fDayMax = offset;
}
// copy the string pointer
fDates[n].offset = offset;
fDates[n].string = aString;
fDates[n].len = aLen;
n++;
}
ures_close(subString);
ures_close(rb);
// the fDates[] array could be sorted here, for direct access.
}
U_CAPI UBool U_EXPORT2
ucol_equals(const UCollator *source, const UCollator *target) {
UErrorCode status = U_ZERO_ERROR;
// if pointers are equal, collators are equal
if(source == target) {
return TRUE;
}
int32_t i = 0, j = 0;
// if any of attributes are different, collators are not equal
for(i = 0; i < UCOL_ATTRIBUTE_COUNT; i++) {
if(ucol_getAttribute(source, (UColAttribute)i, &status) != ucol_getAttribute(target, (UColAttribute)i, &status) || U_FAILURE(status)) {
return FALSE;
}
}
int32_t sourceRulesLen = 0, targetRulesLen = 0;
const UChar *sourceRules = ucol_getRules(source, &sourceRulesLen);
const UChar *targetRules = ucol_getRules(target, &targetRulesLen);
if(sourceRulesLen == targetRulesLen && u_strncmp(sourceRules, targetRules, sourceRulesLen) == 0) {
// all the attributes are equal and the rules are equal - collators are equal
return(TRUE);
}
// hard part, need to construct tree from rules and see if they yield the same tailoring
UBool result = TRUE;
UParseError parseError;
UColTokenParser sourceParser, targetParser;
int32_t sourceListLen = 0, targetListLen = 0;
ucol_tok_initTokenList(&sourceParser, sourceRules, sourceRulesLen, source->UCA, &status);
ucol_tok_initTokenList(&targetParser, targetRules, targetRulesLen, target->UCA, &status);
sourceListLen = ucol_tok_assembleTokenList(&sourceParser, &parseError, &status);
targetListLen = ucol_tok_assembleTokenList(&targetParser, &parseError, &status);
if(sourceListLen != targetListLen) {
// different number of resets
result = FALSE;
} else {
UColToken *sourceReset = NULL, *targetReset = NULL;
UChar *sourceResetString = NULL, *targetResetString = NULL;
int32_t sourceStringLen = 0, targetStringLen = 0;
for(i = 0; i < sourceListLen; i++) {
sourceReset = sourceParser.lh[i].reset;
sourceResetString = sourceParser.source+(sourceReset->source & 0xFFFFFF);
sourceStringLen = sourceReset->source >> 24;
for(j = 0; j < sourceListLen; j++) {
targetReset = targetParser.lh[j].reset;
targetResetString = targetParser.source+(targetReset->source & 0xFFFFFF);
targetStringLen = targetReset->source >> 24;
if(sourceStringLen == targetStringLen && (u_strncmp(sourceResetString, targetResetString, sourceStringLen) == 0)) {
sourceReset = sourceParser.lh[i].first;
targetReset = targetParser.lh[j].first;
while(sourceReset != NULL && targetReset != NULL) {
sourceResetString = sourceParser.source+(sourceReset->source & 0xFFFFFF);
sourceStringLen = sourceReset->source >> 24;
targetResetString = targetParser.source+(targetReset->source & 0xFFFFFF);
targetStringLen = targetReset->source >> 24;
if(sourceStringLen != targetStringLen || (u_strncmp(sourceResetString, targetResetString, sourceStringLen) != 0)) {
result = FALSE;
goto returnResult;
}
// probably also need to check the expansions
if(sourceReset->expansion) {
if(!targetReset->expansion) {
result = FALSE;
goto returnResult;
} else {
// compare expansions
sourceResetString = sourceParser.source+(sourceReset->expansion& 0xFFFFFF);
sourceStringLen = sourceReset->expansion >> 24;
targetResetString = targetParser.source+(targetReset->expansion & 0xFFFFFF);
targetStringLen = targetReset->expansion >> 24;
if(sourceStringLen != targetStringLen || (u_strncmp(sourceResetString, targetResetString, sourceStringLen) != 0)) {
result = FALSE;
goto returnResult;
}
}
} else {
if(targetReset->expansion) {
result = FALSE;
goto returnResult;
}
}
sourceReset = sourceReset->next;
targetReset = targetReset->next;
}
if(sourceReset != targetReset) { // at least one is not NULL
// there are more tailored elements in one list
result = FALSE;
goto returnResult;
}
break;
}
}
// couldn't find the reset anchor, so the collators are not equal
if(j == sourceListLen) {
result = FALSE;
goto returnResult;
}
}
U_CAPI int32_t U_EXPORT2
uspoof_areConfusable(const USpoofChecker *sc,
const UChar *s1, int32_t length1,
const UChar *s2, int32_t length2,
UErrorCode *status) {
const SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
if (U_FAILURE(*status)) {
return 0;
}
//
// See section 4 of UAX 39 for the algorithm for checking whether two strings are confusable,
// and for definitions of the types (single, whole, mixed-script) of confusables.
// We only care about a few of the check flags. Ignore the others.
// If no tests relavant to this function have been specified, return an error.
// TODO: is this really the right thing to do? It's probably an error on the caller's part,
// but logically we would just return 0 (no error).
if ((This->fChecks & (USPOOF_SINGLE_SCRIPT_CONFUSABLE | USPOOF_MIXED_SCRIPT_CONFUSABLE |
USPOOF_WHOLE_SCRIPT_CONFUSABLE)) == 0) {
*status = U_INVALID_STATE_ERROR;
return 0;
}
int32_t flagsForSkeleton = This->fChecks & USPOOF_ANY_CASE;
UChar s1SkeletonBuf[USPOOF_STACK_BUFFER_SIZE];
UChar *s1Skeleton;
int32_t s1SkeletonLength = 0;
UChar s2SkeletonBuf[USPOOF_STACK_BUFFER_SIZE];
UChar *s2Skeleton;
int32_t s2SkeletonLength = 0;
int32_t result = 0;
int32_t t;
int32_t s1ScriptCount = This->scriptScan(s1, length1, t, *status);
int32_t s2ScriptCount = This->scriptScan(s2, length2, t, *status);
if (This->fChecks & USPOOF_SINGLE_SCRIPT_CONFUSABLE) {
// Do the Single Script compare.
if (s1ScriptCount <= 1 && s2ScriptCount <= 1) {
flagsForSkeleton |= USPOOF_SINGLE_SCRIPT_CONFUSABLE;
s1Skeleton = getSkeleton(sc, flagsForSkeleton, s1, length1, s1SkeletonBuf,
sizeof(s1SkeletonBuf)/sizeof(UChar), &s1SkeletonLength, status);
s2Skeleton = getSkeleton(sc, flagsForSkeleton, s2, length2, s2SkeletonBuf,
sizeof(s2SkeletonBuf)/sizeof(UChar), &s2SkeletonLength, status);
if (s1SkeletonLength == s2SkeletonLength && u_strncmp(s1Skeleton, s2Skeleton, s1SkeletonLength) == 0) {
result |= USPOOF_SINGLE_SCRIPT_CONFUSABLE;
}
if (s1Skeleton != s1SkeletonBuf) {
uprv_free(s1Skeleton);
}
if (s2Skeleton != s2SkeletonBuf) {
uprv_free(s2Skeleton);
}
}
}
if (result & USPOOF_SINGLE_SCRIPT_CONFUSABLE) {
// If the two inputs are single script confusable they cannot also be
// mixed or whole script confusable, according to the UAX39 definitions.
// So we can skip those tests.
return result;
}
// Optimization for whole script confusables test: two identifiers are whole script confusable if
// each is of a single script and they are mixed script confusable.
UBool possiblyWholeScriptConfusables =
s1ScriptCount <= 1 && s2ScriptCount <= 1 && (This->fChecks & USPOOF_WHOLE_SCRIPT_CONFUSABLE);
//
// Mixed Script Check
//
if ((This->fChecks & USPOOF_MIXED_SCRIPT_CONFUSABLE) || possiblyWholeScriptConfusables ) {
// For getSkeleton(), resetting the USPOOF_SINGLE_SCRIPT_CONFUSABLE flag will get us
// the mixed script table skeleton, which is what we want.
// The Any Case / Lower Case bit in the skelton flags was set at the top of the function.
flagsForSkeleton &= ~USPOOF_SINGLE_SCRIPT_CONFUSABLE;
s1Skeleton = getSkeleton(sc, flagsForSkeleton, s1, length1, s1SkeletonBuf,
sizeof(s1SkeletonBuf)/sizeof(UChar), &s1SkeletonLength, status);
s2Skeleton = getSkeleton(sc, flagsForSkeleton, s2, length2, s2SkeletonBuf,
sizeof(s2SkeletonBuf)/sizeof(UChar), &s2SkeletonLength, status);
if (s1SkeletonLength == s2SkeletonLength && u_strncmp(s1Skeleton, s2Skeleton, s1SkeletonLength) == 0) {
result |= USPOOF_MIXED_SCRIPT_CONFUSABLE;
if (possiblyWholeScriptConfusables) {
result |= USPOOF_WHOLE_SCRIPT_CONFUSABLE;
}
}
if (s1Skeleton != s1SkeletonBuf) {
uprv_free(s1Skeleton);
}
if (s2Skeleton != s2SkeletonBuf) {
uprv_free(s2Skeleton);
}
}
return result;
}
EraRules* EraRules::createInstance(const char *calType, UBool includeTentativeEra, UErrorCode& status) {
if(U_FAILURE(status)) {
return nullptr;
}
LocalUResourceBundlePointer rb(ures_openDirect(nullptr, "supplementalData", &status));
ures_getByKey(rb.getAlias(), "calendarData", rb.getAlias(), &status);
ures_getByKey(rb.getAlias(), calType, rb.getAlias(), &status);
ures_getByKey(rb.getAlias(), "eras", rb.getAlias(), &status);
if (U_FAILURE(status)) {
return nullptr;
}
int32_t numEras = ures_getSize(rb.getAlias());
int32_t firstTentativeIdx = MAX_INT32;
LocalMemory<int32_t> startDates(static_cast<int32_t *>(uprv_malloc(numEras * sizeof(int32_t))));
if (startDates.isNull()) {
status = U_MEMORY_ALLOCATION_ERROR;
return nullptr;
}
uprv_memset(startDates.getAlias(), 0 , numEras * sizeof(int32_t));
while (ures_hasNext(rb.getAlias())) {
LocalUResourceBundlePointer eraRuleRes(ures_getNextResource(rb.getAlias(), nullptr, &status));
if (U_FAILURE(status)) {
return nullptr;
}
const char *eraIdxStr = ures_getKey(eraRuleRes.getAlias());
char *endp;
int32_t eraIdx = (int32_t)strtol(eraIdxStr, &endp, 10);
if ((size_t)(endp - eraIdxStr) != uprv_strlen(eraIdxStr)) {
status = U_INVALID_FORMAT_ERROR;
return nullptr;
}
if (eraIdx < 0 || eraIdx >= numEras) {
status = U_INVALID_FORMAT_ERROR;
return nullptr;
}
if (isSet(startDates[eraIdx])) {
// start date of the index was already set
status = U_INVALID_FORMAT_ERROR;
return nullptr;
}
UBool hasName = TRUE;
UBool hasEnd = TRUE;
int32_t len;
while (ures_hasNext(eraRuleRes.getAlias())) {
LocalUResourceBundlePointer res(ures_getNextResource(eraRuleRes.getAlias(), nullptr, &status));
if (U_FAILURE(status)) {
return nullptr;
}
const char *key = ures_getKey(res.getAlias());
if (uprv_strcmp(key, "start") == 0) {
const int32_t *fields = ures_getIntVector(res.getAlias(), &len, &status);
if (U_FAILURE(status)) {
return nullptr;
}
if (len != 3 || !isValidRuleStartDate(fields[0], fields[1], fields[2])) {
status = U_INVALID_FORMAT_ERROR;
return nullptr;
}
startDates[eraIdx] = encodeDate(fields[0], fields[1], fields[2]);
} else if (uprv_strcmp(key, "named") == 0) {
const UChar *val = ures_getString(res.getAlias(), &len, &status);
if (u_strncmp(val, VAL_FALSE, VAL_FALSE_LEN) == 0) {
hasName = FALSE;
}
} else if (uprv_strcmp(key, "end") == 0) {
hasEnd = TRUE;
}
}
if (isSet(startDates[eraIdx])) {
if (hasEnd) {
// This implementation assumes either start or end is available, not both.
// For now, just ignore the end rule.
}
} else {
if (hasEnd) {
if (eraIdx != 0) {
// This implementation does not support end only rule for eras other than
// the first one.
status = U_INVALID_FORMAT_ERROR;
return nullptr;
}
U_ASSERT(eraIdx == 0);
startDates[eraIdx] = MIN_ENCODED_START;
} else {
status = U_INVALID_FORMAT_ERROR;
return nullptr;
}
}
if (hasName) {
if (eraIdx >= firstTentativeIdx) {
status = U_INVALID_FORMAT_ERROR;
return nullptr;
}
} else {
if (eraIdx < firstTentativeIdx) {
firstTentativeIdx = eraIdx;
}
}
}
EraRules *result;
if (firstTentativeIdx < MAX_INT32 && !includeTentativeEra) {
result = new EraRules(startDates, firstTentativeIdx);
} else {
result = new EraRules(startDates, numEras);
}
if (result == nullptr) {
status = U_MEMORY_ALLOCATION_ERROR;
}
return result;
}
static void TestRegexCAPI(void) {
UErrorCode status = U_ZERO_ERROR;
URegularExpression *re;
UChar pat[200];
UChar *minus1;
memset(&minus1, -1, sizeof(minus1));
/* Mimimalist open/close */
u_uastrncpy(pat, "abc*", sizeof(pat)/2);
re = uregex_open(pat, -1, 0, 0, &status);
TEST_ASSERT_SUCCESS(status);
uregex_close(re);
/* Open with all flag values set */
status = U_ZERO_ERROR;
re = uregex_open(pat, -1,
UREGEX_CASE_INSENSITIVE | UREGEX_COMMENTS | UREGEX_DOTALL | UREGEX_MULTILINE | UREGEX_UWORD,
0, &status);
TEST_ASSERT_SUCCESS(status);
uregex_close(re);
/* Open with an invalid flag */
status = U_ZERO_ERROR;
re = uregex_open(pat, -1, 0x40000000, 0, &status);
TEST_ASSERT(status == U_REGEX_INVALID_FLAG);
uregex_close(re);
/* openC with an invalid parameter */
status = U_ZERO_ERROR;
re = uregex_openC(NULL,
UREGEX_CASE_INSENSITIVE | UREGEX_COMMENTS | UREGEX_DOTALL | UREGEX_MULTILINE | UREGEX_UWORD, 0, &status);
TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR && re == NULL);
/* openC with an invalid parameter */
status = U_USELESS_COLLATOR_ERROR;
re = uregex_openC(NULL,
UREGEX_CASE_INSENSITIVE | UREGEX_COMMENTS | UREGEX_DOTALL | UREGEX_MULTILINE | UREGEX_UWORD, 0, &status);
TEST_ASSERT(status == U_USELESS_COLLATOR_ERROR && re == NULL);
/* openC open from a C string */
{
const UChar *p;
int32_t len;
status = U_ZERO_ERROR;
re = uregex_openC("abc*", 0, 0, &status);
TEST_ASSERT_SUCCESS(status);
p = uregex_pattern(re, &len, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS above should change too... */
if(U_SUCCESS(status)) {
u_uastrncpy(pat, "abc*", sizeof(pat)/2);
TEST_ASSERT(u_strcmp(pat, p) == 0);
TEST_ASSERT(len==(int32_t)strlen("abc*"));
}
uregex_close(re);
/* TODO: Open with ParseError parameter */
}
/*
* clone
*/
{
URegularExpression *clone1;
URegularExpression *clone2;
URegularExpression *clone3;
UChar testString1[30];
UChar testString2[30];
UBool result;
status = U_ZERO_ERROR;
re = uregex_openC("abc*", 0, 0, &status);
TEST_ASSERT_SUCCESS(status);
clone1 = uregex_clone(re, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT(clone1 != NULL);
status = U_ZERO_ERROR;
clone2 = uregex_clone(re, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT(clone2 != NULL);
uregex_close(re);
status = U_ZERO_ERROR;
clone3 = uregex_clone(clone2, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT(clone3 != NULL);
u_uastrncpy(testString1, "abcccd", sizeof(pat)/2);
u_uastrncpy(testString2, "xxxabcccd", sizeof(pat)/2);
status = U_ZERO_ERROR;
uregex_setText(clone1, testString1, -1, &status);
TEST_ASSERT_SUCCESS(status);
result = uregex_lookingAt(clone1, 0, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT(result==TRUE);
status = U_ZERO_ERROR;
uregex_setText(clone2, testString2, -1, &status);
TEST_ASSERT_SUCCESS(status);
result = uregex_lookingAt(clone2, 0, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT(result==FALSE);
result = uregex_find(clone2, 0, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT(result==TRUE);
uregex_close(clone1);
uregex_close(clone2);
uregex_close(clone3);
}
/*
* pattern()
*/
{
const UChar *resultPat;
int32_t resultLen;
u_uastrncpy(pat, "hello", sizeof(pat)/2);
status = U_ZERO_ERROR;
re = uregex_open(pat, -1, 0, NULL, &status);
resultPat = uregex_pattern(re, &resultLen, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS above should change too... */
if (U_SUCCESS(status)) {
TEST_ASSERT(resultLen == -1);
TEST_ASSERT(u_strcmp(resultPat, pat) == 0);
}
uregex_close(re);
status = U_ZERO_ERROR;
re = uregex_open(pat, 3, 0, NULL, &status);
resultPat = uregex_pattern(re, &resultLen, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS above should change too... */
if (U_SUCCESS(status)) {
TEST_ASSERT(resultLen == 3);
TEST_ASSERT(u_strncmp(resultPat, pat, 3) == 0);
TEST_ASSERT(u_strlen(resultPat) == 3);
}
uregex_close(re);
}
/*
* flags()
*/
{
int32_t t;
status = U_ZERO_ERROR;
re = uregex_open(pat, -1, 0, NULL, &status);
t = uregex_flags(re, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT(t == 0);
uregex_close(re);
status = U_ZERO_ERROR;
re = uregex_open(pat, -1, 0, NULL, &status);
t = uregex_flags(re, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT(t == 0);
uregex_close(re);
status = U_ZERO_ERROR;
re = uregex_open(pat, -1, UREGEX_CASE_INSENSITIVE | UREGEX_DOTALL, NULL, &status);
t = uregex_flags(re, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT(t == (UREGEX_CASE_INSENSITIVE | UREGEX_DOTALL));
uregex_close(re);
}
/*
* setText() and lookingAt()
*/
{
UChar text1[50];
UChar text2[50];
UBool result;
u_uastrncpy(text1, "abcccd", sizeof(text1)/2);
u_uastrncpy(text2, "abcccxd", sizeof(text2)/2);
status = U_ZERO_ERROR;
u_uastrncpy(pat, "abc*d", sizeof(pat)/2);
re = uregex_open(pat, -1, 0, NULL, &status);
TEST_ASSERT_SUCCESS(status);
/* Operation before doing a setText should fail... */
status = U_ZERO_ERROR;
uregex_lookingAt(re, 0, &status);
TEST_ASSERT( status== U_REGEX_INVALID_STATE);
status = U_ZERO_ERROR;
uregex_setText(re, text1, -1, &status);
result = uregex_lookingAt(re, 0, &status);
TEST_ASSERT(result == TRUE);
TEST_ASSERT_SUCCESS(status);
status = U_ZERO_ERROR;
uregex_setText(re, text2, -1, &status);
result = uregex_lookingAt(re, 0, &status);
TEST_ASSERT(result == FALSE);
TEST_ASSERT_SUCCESS(status);
status = U_ZERO_ERROR;
uregex_setText(re, text1, -1, &status);
result = uregex_lookingAt(re, 0, &status);
TEST_ASSERT(result == TRUE);
TEST_ASSERT_SUCCESS(status);
status = U_ZERO_ERROR;
uregex_setText(re, text1, 5, &status);
result = uregex_lookingAt(re, 0, &status);
TEST_ASSERT(result == FALSE);
TEST_ASSERT_SUCCESS(status);
status = U_ZERO_ERROR;
uregex_setText(re, text1, 6, &status);
result = uregex_lookingAt(re, 0, &status);
TEST_ASSERT(result == TRUE);
TEST_ASSERT_SUCCESS(status);
uregex_close(re);
}
/*
* getText()
*/
{
UChar text1[50];
UChar text2[50];
const UChar *result;
int32_t textLength;
u_uastrncpy(text1, "abcccd", sizeof(text1)/2);
u_uastrncpy(text2, "abcccxd", sizeof(text2)/2);
status = U_ZERO_ERROR;
u_uastrncpy(pat, "abc*d", sizeof(pat)/2);
re = uregex_open(pat, -1, 0, NULL, &status);
uregex_setText(re, text1, -1, &status);
result = uregex_getText(re, &textLength, &status);
TEST_ASSERT(result == text1);
TEST_ASSERT(textLength == -1);
TEST_ASSERT_SUCCESS(status);
status = U_ZERO_ERROR;
uregex_setText(re, text2, 7, &status);
result = uregex_getText(re, &textLength, &status);
TEST_ASSERT(result == text2);
TEST_ASSERT(textLength == 7);
TEST_ASSERT_SUCCESS(status);
status = U_ZERO_ERROR;
uregex_setText(re, text2, 4, &status);
result = uregex_getText(re, &textLength, &status);
TEST_ASSERT(result == text2);
TEST_ASSERT(textLength == 4);
TEST_ASSERT_SUCCESS(status);
uregex_close(re);
}
/*
* matches()
*/
{
UChar text1[50];
UBool result;
int len;
UChar nullString[] = {0,0,0};
u_uastrncpy(text1, "abcccde", sizeof(text1)/2);
status = U_ZERO_ERROR;
u_uastrncpy(pat, "abc*d", sizeof(pat)/2);
re = uregex_open(pat, -1, 0, NULL, &status);
uregex_setText(re, text1, -1, &status);
result = uregex_matches(re, 0, &status);
TEST_ASSERT(result == FALSE);
TEST_ASSERT_SUCCESS(status);
status = U_ZERO_ERROR;
uregex_setText(re, text1, 6, &status);
result = uregex_matches(re, 0, &status);
TEST_ASSERT(result == TRUE);
TEST_ASSERT_SUCCESS(status);
status = U_ZERO_ERROR;
uregex_setText(re, text1, 6, &status);
result = uregex_matches(re, 1, &status);
TEST_ASSERT(result == FALSE);
TEST_ASSERT_SUCCESS(status);
uregex_close(re);
status = U_ZERO_ERROR;
re = uregex_openC(".?", 0, NULL, &status);
uregex_setText(re, text1, -1, &status);
len = u_strlen(text1);
result = uregex_matches(re, len, &status);
TEST_ASSERT(result == TRUE);
TEST_ASSERT_SUCCESS(status);
status = U_ZERO_ERROR;
uregex_setText(re, nullString, -1, &status);
TEST_ASSERT_SUCCESS(status);
result = uregex_matches(re, 0, &status);
TEST_ASSERT(result == TRUE);
TEST_ASSERT_SUCCESS(status);
uregex_close(re);
}
/*
* lookingAt() Used in setText test.
*/
/*
* find(), findNext, start, end, reset
*/
{
UChar text1[50];
UBool result;
u_uastrncpy(text1, "012rx5rx890rxrx...", sizeof(text1)/2);
status = U_ZERO_ERROR;
re = uregex_openC("rx", 0, NULL, &status);
uregex_setText(re, text1, -1, &status);
result = uregex_find(re, 0, &status);
TEST_ASSERT(result == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 3);
TEST_ASSERT(uregex_end(re, 0, &status) == 5);
TEST_ASSERT_SUCCESS(status);
result = uregex_find(re, 9, &status);
TEST_ASSERT(result == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 11);
TEST_ASSERT(uregex_end(re, 0, &status) == 13);
TEST_ASSERT_SUCCESS(status);
result = uregex_find(re, 14, &status);
TEST_ASSERT(result == FALSE);
TEST_ASSERT_SUCCESS(status);
status = U_ZERO_ERROR;
uregex_reset(re, 0, &status);
result = uregex_findNext(re, &status);
TEST_ASSERT(result == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 3);
TEST_ASSERT(uregex_end(re, 0, &status) == 5);
TEST_ASSERT_SUCCESS(status);
result = uregex_findNext(re, &status);
TEST_ASSERT(result == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 6);
TEST_ASSERT(uregex_end(re, 0, &status) == 8);
TEST_ASSERT_SUCCESS(status);
status = U_ZERO_ERROR;
uregex_reset(re, 12, &status);
result = uregex_findNext(re, &status);
TEST_ASSERT(result == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 13);
TEST_ASSERT(uregex_end(re, 0, &status) == 15);
TEST_ASSERT_SUCCESS(status);
result = uregex_findNext(re, &status);
TEST_ASSERT(result == FALSE);
TEST_ASSERT_SUCCESS(status);
uregex_close(re);
}
/*
* groupCount
*/
{
int32_t result;
status = U_ZERO_ERROR;
re = uregex_openC("abc", 0, NULL, &status);
result = uregex_groupCount(re, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT(result == 0);
uregex_close(re);
status = U_ZERO_ERROR;
re = uregex_openC("abc(def)(ghi(j))", 0, NULL, &status);
result = uregex_groupCount(re, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT(result == 3);
uregex_close(re);
}
/*
* group()
*/
{
UChar text1[80];
UChar buf[80];
UBool result;
int32_t resultSz;
u_uastrncpy(text1, "noise abc interior def, and this is off the end", sizeof(text1)/2);
status = U_ZERO_ERROR;
re = uregex_openC("abc(.*?)def", 0, NULL, &status);
TEST_ASSERT_SUCCESS(status);
uregex_setText(re, text1, -1, &status);
result = uregex_find(re, 0, &status);
TEST_ASSERT(result==TRUE);
/* Capture Group 0, the full match. Should succeed. */
status = U_ZERO_ERROR;
resultSz = uregex_group(re, 0, buf, sizeof(buf)/2, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT_STRING("abc interior def", buf, TRUE);
TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def"));
/* Capture group #1. Should succeed. */
status = U_ZERO_ERROR;
resultSz = uregex_group(re, 1, buf, sizeof(buf)/2, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT_STRING(" interior ", buf, TRUE);
TEST_ASSERT(resultSz == (int32_t)strlen(" interior "));
/* Capture group out of range. Error. */
status = U_ZERO_ERROR;
uregex_group(re, 2, buf, sizeof(buf)/2, &status);
TEST_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
/* NULL buffer, pure pre-flight */
status = U_ZERO_ERROR;
resultSz = uregex_group(re, 0, NULL, 0, &status);
TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def"));
/* Too small buffer, truncated string */
status = U_ZERO_ERROR;
memset(buf, -1, sizeof(buf));
resultSz = uregex_group(re, 0, buf, 5, &status);
TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
TEST_ASSERT_STRING("abc i", buf, FALSE);
TEST_ASSERT(buf[5] == (UChar)0xffff);
TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def"));
/* Output string just fits buffer, no NUL term. */
status = U_ZERO_ERROR;
resultSz = uregex_group(re, 0, buf, (int32_t)strlen("abc interior def"), &status);
TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
TEST_ASSERT_STRING("abc interior def", buf, FALSE);
TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def"));
TEST_ASSERT(buf[strlen("abc interior def")] == (UChar)0xffff);
uregex_close(re);
}
/*
* Regions
*/
/* SetRegion(), getRegion() do something */
TEST_SETUP(".*", "0123456789ABCDEF", 0)
UChar resultString[40];
TEST_ASSERT(uregex_regionStart(re, &status) == 0);
TEST_ASSERT(uregex_regionEnd(re, &status) == 16);
uregex_setRegion(re, 3, 6, &status);
TEST_ASSERT(uregex_regionStart(re, &status) == 3);
TEST_ASSERT(uregex_regionEnd(re, &status) == 6);
TEST_ASSERT(uregex_findNext(re, &status));
TEST_ASSERT(uregex_group(re, 0, resultString, sizeof(resultString)/2, &status) == 3)
TEST_ASSERT_STRING("345", resultString, TRUE);
TEST_TEARDOWN;
/* find(start=-1) uses regions */
TEST_SETUP(".*", "0123456789ABCDEF", 0);
uregex_setRegion(re, 4, 6, &status);
TEST_ASSERT(uregex_find(re, -1, &status) == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 4);
TEST_ASSERT(uregex_end(re, 0, &status) == 6);
TEST_TEARDOWN;
/* find (start >=0) does not use regions */
TEST_SETUP(".*", "0123456789ABCDEF", 0);
uregex_setRegion(re, 4, 6, &status);
TEST_ASSERT(uregex_find(re, 0, &status) == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 0);
TEST_ASSERT(uregex_end(re, 0, &status) == 16);
TEST_TEARDOWN;
/* findNext() obeys regions */
TEST_SETUP(".", "0123456789ABCDEF", 0);
uregex_setRegion(re, 4, 6, &status);
TEST_ASSERT(uregex_findNext(re,&status) == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 4);
TEST_ASSERT(uregex_findNext(re, &status) == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 5);
TEST_ASSERT(uregex_findNext(re, &status) == FALSE);
TEST_TEARDOWN;
/* matches(start=-1) uses regions */
/* Also, verify that non-greedy *? succeeds in finding the full match. */
TEST_SETUP(".*?", "0123456789ABCDEF", 0);
uregex_setRegion(re, 4, 6, &status);
TEST_ASSERT(uregex_matches(re, -1, &status) == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 4);
TEST_ASSERT(uregex_end(re, 0, &status) == 6);
TEST_TEARDOWN;
/* matches (start >=0) does not use regions */
TEST_SETUP(".*?", "0123456789ABCDEF", 0);
uregex_setRegion(re, 4, 6, &status);
TEST_ASSERT(uregex_matches(re, 0, &status) == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 0);
TEST_ASSERT(uregex_end(re, 0, &status) == 16);
TEST_TEARDOWN;
/* lookingAt(start=-1) uses regions */
/* Also, verify that non-greedy *? finds the first (shortest) match. */
TEST_SETUP(".*?", "0123456789ABCDEF", 0);
uregex_setRegion(re, 4, 6, &status);
TEST_ASSERT(uregex_lookingAt(re, -1, &status) == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 4);
TEST_ASSERT(uregex_end(re, 0, &status) == 4);
TEST_TEARDOWN;
/* lookingAt (start >=0) does not use regions */
TEST_SETUP(".*?", "0123456789ABCDEF", 0);
uregex_setRegion(re, 4, 6, &status);
TEST_ASSERT(uregex_lookingAt(re, 0, &status) == TRUE);
TEST_ASSERT(uregex_start(re, 0, &status) == 0);
TEST_ASSERT(uregex_end(re, 0, &status) == 0);
TEST_TEARDOWN;
/* hitEnd() */
TEST_SETUP("[a-f]*", "abcdefghij", 0);
TEST_ASSERT(uregex_find(re, 0, &status) == TRUE);
TEST_ASSERT(uregex_hitEnd(re, &status) == FALSE);
TEST_TEARDOWN;
TEST_SETUP("[a-f]*", "abcdef", 0);
TEST_ASSERT(uregex_find(re, 0, &status) == TRUE);
TEST_ASSERT(uregex_hitEnd(re, &status) == TRUE);
TEST_TEARDOWN;
/* requireEnd */
TEST_SETUP("abcd", "abcd", 0);
TEST_ASSERT(uregex_find(re, 0, &status) == TRUE);
TEST_ASSERT(uregex_requireEnd(re, &status) == FALSE);
TEST_TEARDOWN;
TEST_SETUP("abcd$", "abcd", 0);
TEST_ASSERT(uregex_find(re, 0, &status) == TRUE);
TEST_ASSERT(uregex_requireEnd(re, &status) == TRUE);
TEST_TEARDOWN;
/* anchoringBounds */
TEST_SETUP("abc$", "abcdef", 0);
TEST_ASSERT(uregex_hasAnchoringBounds(re, &status) == TRUE);
uregex_useAnchoringBounds(re, FALSE, &status);
TEST_ASSERT(uregex_hasAnchoringBounds(re, &status) == FALSE);
TEST_ASSERT(uregex_find(re, -1, &status) == FALSE);
uregex_useAnchoringBounds(re, TRUE, &status);
uregex_setRegion(re, 0, 3, &status);
TEST_ASSERT(uregex_find(re, -1, &status) == TRUE);
TEST_ASSERT(uregex_end(re, 0, &status) == 3);
TEST_TEARDOWN;
/* Transparent Bounds */
TEST_SETUP("abc(?=def)", "abcdef", 0);
TEST_ASSERT(uregex_hasTransparentBounds(re, &status) == FALSE);
uregex_useTransparentBounds(re, TRUE, &status);
TEST_ASSERT(uregex_hasTransparentBounds(re, &status) == TRUE);
uregex_useTransparentBounds(re, FALSE, &status);
TEST_ASSERT(uregex_find(re, -1, &status) == TRUE); /* No Region */
uregex_setRegion(re, 0, 3, &status);
TEST_ASSERT(uregex_find(re, -1, &status) == FALSE); /* with region, opaque bounds */
uregex_useTransparentBounds(re, TRUE, &status);
TEST_ASSERT(uregex_find(re, -1, &status) == TRUE); /* with region, transparent bounds */
TEST_ASSERT(uregex_end(re, 0, &status) == 3);
TEST_TEARDOWN;
/*
* replaceFirst()
*/
{
UChar text1[80];
UChar text2[80];
UChar replText[80];
UChar buf[80];
int32_t resultSz;
u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2);
u_uastrncpy(text2, "No match here.", sizeof(text2)/2);
u_uastrncpy(replText, "<$1>", sizeof(replText)/2);
status = U_ZERO_ERROR;
re = uregex_openC("x(.*?)x", 0, NULL, &status);
TEST_ASSERT_SUCCESS(status);
/* Normal case, with match */
uregex_setText(re, text1, -1, &status);
resultSz = uregex_replaceFirst(re, replText, -1, buf, sizeof(buf)/2, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT_STRING("Replace <aa> x1x x...x.", buf, TRUE);
TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
/* No match. Text should copy to output with no changes. */
status = U_ZERO_ERROR;
uregex_setText(re, text2, -1, &status);
resultSz = uregex_replaceFirst(re, replText, -1, buf, sizeof(buf)/2, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT_STRING("No match here.", buf, TRUE);
TEST_ASSERT(resultSz == (int32_t)strlen("No match here."));
/* Match, output just fills buffer, no termination warning. */
status = U_ZERO_ERROR;
uregex_setText(re, text1, -1, &status);
memset(buf, -1, sizeof(buf));
resultSz = uregex_replaceFirst(re, replText, -1, buf, strlen("Replace <aa> x1x x...x."), &status);
TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
TEST_ASSERT_STRING("Replace <aa> x1x x...x.", buf, FALSE);
TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
TEST_ASSERT(buf[resultSz] == (UChar)0xffff);
/* Do the replaceFirst again, without first resetting anything.
* Should give the same results.
*/
status = U_ZERO_ERROR;
memset(buf, -1, sizeof(buf));
resultSz = uregex_replaceFirst(re, replText, -1, buf, strlen("Replace <aa> x1x x...x."), &status);
TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
TEST_ASSERT_STRING("Replace <aa> x1x x...x.", buf, FALSE);
TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
TEST_ASSERT(buf[resultSz] == (UChar)0xffff);
/* NULL buffer, zero buffer length */
status = U_ZERO_ERROR;
resultSz = uregex_replaceFirst(re, replText, -1, NULL, 0, &status);
TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
/* Buffer too small by one */
status = U_ZERO_ERROR;
memset(buf, -1, sizeof(buf));
resultSz = uregex_replaceFirst(re, replText, -1, buf, strlen("Replace <aa> x1x x...x.")-1, &status);
TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
TEST_ASSERT_STRING("Replace <aa> x1x x...x", buf, FALSE);
TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
TEST_ASSERT(buf[resultSz] == (UChar)0xffff);
uregex_close(re);
}
/*
* replaceAll()
*/
{
UChar text1[80];
UChar text2[80];
UChar replText[80];
UChar buf[80];
int32_t resultSz;
int32_t expectedResultSize;
int32_t i;
u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2);
u_uastrncpy(text2, "No match here.", sizeof(text2)/2);
u_uastrncpy(replText, "<$1>", sizeof(replText)/2);
expectedResultSize = u_strlen(text1);
status = U_ZERO_ERROR;
re = uregex_openC("x(.*?)x", 0, NULL, &status);
TEST_ASSERT_SUCCESS(status);
/* Normal case, with match */
uregex_setText(re, text1, -1, &status);
resultSz = uregex_replaceAll(re, replText, -1, buf, sizeof(buf)/2, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT_STRING("Replace <aa> <1> <...>.", buf, TRUE);
TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
/* No match. Text should copy to output with no changes. */
status = U_ZERO_ERROR;
uregex_setText(re, text2, -1, &status);
resultSz = uregex_replaceAll(re, replText, -1, buf, sizeof(buf)/2, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT_STRING("No match here.", buf, TRUE);
TEST_ASSERT(resultSz == (int32_t)strlen("No match here."));
/* Match, output just fills buffer, no termination warning. */
status = U_ZERO_ERROR;
uregex_setText(re, text1, -1, &status);
memset(buf, -1, sizeof(buf));
resultSz = uregex_replaceAll(re, replText, -1, buf, strlen("Replace xaax x1x x...x."), &status);
TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
TEST_ASSERT_STRING("Replace <aa> <1> <...>.", buf, FALSE);
TEST_ASSERT(resultSz == (int32_t)strlen("Replace <aa> <1> <...>."));
TEST_ASSERT(buf[resultSz] == (UChar)0xffff);
/* Do the replaceFirst again, without first resetting anything.
* Should give the same results.
*/
status = U_ZERO_ERROR;
memset(buf, -1, sizeof(buf));
resultSz = uregex_replaceAll(re, replText, -1, buf, strlen("Replace xaax x1x x...x."), &status);
TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
TEST_ASSERT_STRING("Replace <aa> <1> <...>.", buf, FALSE);
TEST_ASSERT(resultSz == (int32_t)strlen("Replace <aa> <1> <...>."));
TEST_ASSERT(buf[resultSz] == (UChar)0xffff);
/* NULL buffer, zero buffer length */
status = U_ZERO_ERROR;
resultSz = uregex_replaceAll(re, replText, -1, NULL, 0, &status);
TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
TEST_ASSERT(resultSz == (int32_t)strlen("Replace <aa> <1> <...>."));
/* Buffer too small. Try every size, which will tickle edge cases
* in uregex_appendReplacement (used by replaceAll) */
for (i=0; i<expectedResultSize; i++) {
char expected[80];
status = U_ZERO_ERROR;
memset(buf, -1, sizeof(buf));
resultSz = uregex_replaceAll(re, replText, -1, buf, i, &status);
TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
strcpy(expected, "Replace <aa> <1> <...>.");
expected[i] = 0;
TEST_ASSERT_STRING(expected, buf, FALSE);
TEST_ASSERT(resultSz == expectedResultSize);
TEST_ASSERT(buf[i] == (UChar)0xffff);
}
uregex_close(re);
}
/*
* appendReplacement()
*/
{
UChar text[100];
UChar repl[100];
UChar buf[100];
UChar *bufPtr;
int32_t bufCap;
status = U_ZERO_ERROR;
re = uregex_openC(".*", 0, 0, &status);
TEST_ASSERT_SUCCESS(status);
u_uastrncpy(text, "whatever", sizeof(text)/2);
u_uastrncpy(repl, "some other", sizeof(repl)/2);
uregex_setText(re, text, -1, &status);
/* match covers whole target string */
uregex_find(re, 0, &status);
TEST_ASSERT_SUCCESS(status);
bufPtr = buf;
bufCap = sizeof(buf) / 2;
uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT_STRING("some other", buf, TRUE);
/* Match has \u \U escapes */
uregex_find(re, 0, &status);
TEST_ASSERT_SUCCESS(status);
bufPtr = buf;
bufCap = sizeof(buf) / 2;
u_uastrncpy(repl, "abc\\u0041\\U00000042 \\\\ $ \\abc", sizeof(repl)/2);
uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT_STRING("abcAB \\ $ abc", buf, TRUE);
uregex_close(re);
}
/*
* appendTail(). Checked in ReplaceFirst(), replaceAll().
*/
/*
* split()
*/
{
UChar textToSplit[80];
UChar text2[80];
UChar buf[200];
UChar *fields[10];
int32_t numFields;
int32_t requiredCapacity;
int32_t spaceNeeded;
int32_t sz;
u_uastrncpy(textToSplit, "first : second: third", sizeof(textToSplit)/2);
u_uastrncpy(text2, "No match here.", sizeof(text2)/2);
status = U_ZERO_ERROR;
re = uregex_openC(":", 0, NULL, &status);
/* Simple split */
uregex_setText(re, textToSplit, -1, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS call above should change too... */
if (U_SUCCESS(status)) {
memset(fields, -1, sizeof(fields));
numFields =
uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 10, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS call above should change too... */
if(U_SUCCESS(status)) {
TEST_ASSERT(numFields == 3);
TEST_ASSERT_STRING("first ", fields[0], TRUE);
TEST_ASSERT_STRING(" second", fields[1], TRUE);
TEST_ASSERT_STRING(" third", fields[2], TRUE);
TEST_ASSERT(fields[3] == NULL);
spaceNeeded = u_strlen(textToSplit) -
(numFields - 1) + /* Field delimiters do not appear in output */
numFields; /* Each field gets a NUL terminator */
TEST_ASSERT(spaceNeeded == requiredCapacity);
}
}
uregex_close(re);
/* Split with too few output strings available */
status = U_ZERO_ERROR;
re = uregex_openC(":", 0, NULL, &status);
uregex_setText(re, textToSplit, -1, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS call above should change too... */
if(U_SUCCESS(status)) {
memset(fields, -1, sizeof(fields));
numFields =
uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 2, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS call above should change too... */
if(U_SUCCESS(status)) {
TEST_ASSERT(numFields == 2);
TEST_ASSERT_STRING("first ", fields[0], TRUE);
TEST_ASSERT_STRING(" second: third", fields[1], TRUE);
TEST_ASSERT(!memcmp(&fields[2],&minus1,sizeof(UChar*)));
spaceNeeded = u_strlen(textToSplit) -
(numFields - 1) + /* Field delimiters do not appear in output */
numFields; /* Each field gets a NUL terminator */
TEST_ASSERT(spaceNeeded == requiredCapacity);
/* Split with a range of output buffer sizes. */
spaceNeeded = u_strlen(textToSplit) -
(numFields - 1) + /* Field delimiters do not appear in output */
numFields; /* Each field gets a NUL terminator */
for (sz=0; sz < spaceNeeded+1; sz++) {
memset(fields, -1, sizeof(fields));
status = U_ZERO_ERROR;
numFields =
uregex_split(re, buf, sz, &requiredCapacity, fields, 10, &status);
if (sz >= spaceNeeded) {
TEST_ASSERT_SUCCESS(status);
TEST_ASSERT_STRING("first ", fields[0], TRUE);
TEST_ASSERT_STRING(" second", fields[1], TRUE);
TEST_ASSERT_STRING(" third", fields[2], TRUE);
} else {
TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
}
TEST_ASSERT(numFields == 3);
TEST_ASSERT(fields[3] == NULL);
TEST_ASSERT(spaceNeeded == requiredCapacity);
}
}
}
uregex_close(re);
}
/* Split(), part 2. Patterns with capture groups. The capture group text
* comes out as additional fields. */
{
UChar textToSplit[80];
UChar buf[200];
UChar *fields[10];
int32_t numFields;
int32_t requiredCapacity;
int32_t spaceNeeded;
int32_t sz;
u_uastrncpy(textToSplit, "first <tag-a> second<tag-b> third", sizeof(textToSplit)/2);
status = U_ZERO_ERROR;
re = uregex_openC("<(.*?)>", 0, NULL, &status);
uregex_setText(re, textToSplit, -1, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS call above should change too... */
if(U_SUCCESS(status)) {
memset(fields, -1, sizeof(fields));
numFields =
uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 10, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS call above should change too... */
if(U_SUCCESS(status)) {
TEST_ASSERT(numFields == 5);
TEST_ASSERT_STRING("first ", fields[0], TRUE);
TEST_ASSERT_STRING("tag-a", fields[1], TRUE);
TEST_ASSERT_STRING(" second", fields[2], TRUE);
TEST_ASSERT_STRING("tag-b", fields[3], TRUE);
TEST_ASSERT_STRING(" third", fields[4], TRUE);
TEST_ASSERT(fields[5] == NULL);
spaceNeeded = strlen("first .tag-a. second.tag-b. third."); /* "." at NUL positions */
TEST_ASSERT(spaceNeeded == requiredCapacity);
}
}
/* Split with too few output strings available (2) */
status = U_ZERO_ERROR;
memset(fields, -1, sizeof(fields));
numFields =
uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 2, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS call above should change too... */
if(U_SUCCESS(status)) {
TEST_ASSERT(numFields == 2);
TEST_ASSERT_STRING("first ", fields[0], TRUE);
TEST_ASSERT_STRING(" second<tag-b> third", fields[1], TRUE);
TEST_ASSERT(!memcmp(&fields[2],&minus1,sizeof(UChar*)));
spaceNeeded = strlen("first . second<tag-b> third."); /* "." at NUL positions */
TEST_ASSERT(spaceNeeded == requiredCapacity);
}
/* Split with too few output strings available (3) */
status = U_ZERO_ERROR;
memset(fields, -1, sizeof(fields));
numFields =
uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 3, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS call above should change too... */
if(U_SUCCESS(status)) {
TEST_ASSERT(numFields == 3);
TEST_ASSERT_STRING("first ", fields[0], TRUE);
TEST_ASSERT_STRING("tag-a", fields[1], TRUE);
TEST_ASSERT_STRING(" second<tag-b> third", fields[2], TRUE);
TEST_ASSERT(!memcmp(&fields[3],&minus1,sizeof(UChar*)));
spaceNeeded = strlen("first .tag-a. second<tag-b> third."); /* "." at NUL positions */
TEST_ASSERT(spaceNeeded == requiredCapacity);
}
/* Split with just enough output strings available (5) */
status = U_ZERO_ERROR;
memset(fields, -1, sizeof(fields));
numFields =
uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 5, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS call above should change too... */
if(U_SUCCESS(status)) {
TEST_ASSERT(numFields == 5);
TEST_ASSERT_STRING("first ", fields[0], TRUE);
TEST_ASSERT_STRING("tag-a", fields[1], TRUE);
TEST_ASSERT_STRING(" second", fields[2], TRUE);
TEST_ASSERT_STRING("tag-b", fields[3], TRUE);
TEST_ASSERT_STRING(" third", fields[4], TRUE);
TEST_ASSERT(!memcmp(&fields[5],&minus1,sizeof(UChar*)));
spaceNeeded = strlen("first .tag-a. second.tag-b. third."); /* "." at NUL positions */
TEST_ASSERT(spaceNeeded == requiredCapacity);
}
/* Split, end of text is a field delimiter. */
status = U_ZERO_ERROR;
sz = strlen("first <tag-a> second<tag-b>");
uregex_setText(re, textToSplit, sz, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS call above should change too... */
if(U_SUCCESS(status)) {
memset(fields, -1, sizeof(fields));
numFields =
uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 9, &status);
TEST_ASSERT_SUCCESS(status);
/* The TEST_ASSERT_SUCCESS call above should change too... */
if(U_SUCCESS(status)) {
TEST_ASSERT(numFields == 4);
TEST_ASSERT_STRING("first ", fields[0], TRUE);
TEST_ASSERT_STRING("tag-a", fields[1], TRUE);
TEST_ASSERT_STRING(" second", fields[2], TRUE);
TEST_ASSERT_STRING("tag-b", fields[3], TRUE);
TEST_ASSERT(fields[4] == NULL);
TEST_ASSERT(fields[8] == NULL);
TEST_ASSERT(!memcmp(&fields[9],&minus1,sizeof(UChar*)));
spaceNeeded = strlen("first .tag-a. second.tag-b."); /* "." at NUL positions */
TEST_ASSERT(spaceNeeded == requiredCapacity);
}
}
uregex_close(re);
}
}
static void verifyEnumeration(int line, UEnumeration *u, const char * const * compareToChar, const UChar * const * compareToUChar, int32_t expect_count) {
UErrorCode status = U_ZERO_ERROR;
int32_t got_count,i,len;
const char *c;
UChar buf[1024];
log_verbose("%s:%d: verifying enumeration..\n", __FILE__, line);
uenum_reset(u, &status);
if(U_FAILURE(status)) {
log_err("%s:%d: FAIL: could not reset char strings enumeration: %s\n", __FILE__, line, u_errorName(status));
return;
}
got_count = uenum_count(u, &status);
if(U_FAILURE(status)) {
log_err("%s:%d: FAIL: could not count char strings enumeration: %s\n", __FILE__, line, u_errorName(status));
return;
}
if(got_count!=expect_count) {
log_err("%s:%d: FAIL: expect count %d got %d\n", __FILE__, line, expect_count, got_count);
} else {
log_verbose("%s:%d: OK: got count %d\n", __FILE__, line, got_count);
}
if(compareToChar!=NULL) { /* else, not invariant */
for(i=0;i<got_count;i++) {
c = uenum_next(u,&len, &status);
if(U_FAILURE(status)) {
log_err("%s:%d: FAIL: could not iterate to next after %d: %s\n", __FILE__, line, i, u_errorName(status));
return;
}
if(c==NULL) {
log_err("%s:%d: FAIL: got NULL for next after %d: %s\n", __FILE__, line, i, u_errorName(status));
return;
}
if(strcmp(c,compareToChar[i])) {
log_err("%s:%d: FAIL: string #%d expected '%s' got '%s'\n", __FILE__, line, i, compareToChar[i], c);
} else {
log_verbose("%s:%d: OK: string #%d got '%s'\n", __FILE__, line, i, c);
}
if(len!=strlen(compareToChar[i])) {
log_err("%s:%d: FAIL: string #%d expected len %d got %d\n", __FILE__, line, i, strlen(compareToChar[i]), len);
} else {
log_verbose("%s:%d: OK: string #%d got len %d\n", __FILE__, line, i, len);
}
}
}
/* now try U */
uenum_reset(u, &status);
if(U_FAILURE(status)) {
log_err("%s:%d: FAIL: could not reset again char strings enumeration: %s\n", __FILE__, line, u_errorName(status));
return;
}
for(i=0;i<got_count;i++) {
const UChar *ustr = uenum_unext(u,&len, &status);
if(U_FAILURE(status)) {
log_err("%s:%d: FAIL: could not iterate to unext after %d: %s\n", __FILE__, line, i, u_errorName(status));
return;
}
if(ustr==NULL) {
log_err("%s:%d: FAIL: got NULL for unext after %d: %s\n", __FILE__, line, i, u_errorName(status));
return;
}
if(compareToChar!=NULL) {
u_charsToUChars(compareToChar[i], buf, strlen(compareToChar[i])+1);
if(u_strncmp(ustr,buf,len)) {
int j;
log_err("%s:%d: FAIL: ustring #%d expected '%s' got '%s'\n", __FILE__, line, i, compareToChar[i], austrdup(ustr));
for(j=0;ustr[j]&&buf[j];j++) {
log_verbose(" @ %d\t<U+%04X> vs <U+%04X>\n", j, ustr[j],buf[j]);
}
} else {
log_verbose("%s:%d: OK: ustring #%d got '%s'\n", __FILE__, line, i, compareToChar[i]);
}
if(len!=strlen(compareToChar[i])) {
log_err("%s:%d: FAIL: ustring #%d expected len %d got %d\n", __FILE__, line, i, strlen(compareToChar[i]), len);
} else {
log_verbose("%s:%d: OK: ustring #%d got len %d\n", __FILE__, line, i, len);
}
}
if(compareToUChar!=NULL) {
if(u_strcmp(ustr,compareToUChar[i])) {
int j;
log_err("%s:%d: FAIL: ustring #%d expected '%s' got '%s'\n", __FILE__, line, i, austrdup(compareToUChar[i]), austrdup(ustr));
for(j=0;ustr[j]&&compareToUChar[j];j++) {
log_verbose(" @ %d\t<U+%04X> vs <U+%04X>\n", j, ustr[j],compareToUChar[j]);
}
} else {
log_verbose("%s:%d: OK: ustring #%d got '%s'\n", __FILE__, line, i, austrdup(compareToUChar[i]));
}
if(len!=u_strlen(compareToUChar[i])) {
log_err("%s:%d: FAIL: ustring #%d expected len %d got %d\n", __FILE__, line, i, u_strlen(compareToUChar[i]), len);
} else {
log_verbose("%s:%d: OK: ustring #%d got len %d\n", __FILE__, line, i, len);
}
}
}
}
static void TestUsage() {
UErrorCode errorCode=U_ZERO_ERROR;
UDateTimePatternGenerator *dtpg;
const AppendItemNameData * appItemNameDataPtr;
UChar bestPattern[20];
UChar result[20];
int32_t length;
UChar *s;
const UChar *r;
dtpg=udatpg_open("fi", &errorCode);
if(U_FAILURE(errorCode)) {
log_err_status(errorCode, "udatpg_open(fi) failed - %s\n", u_errorName(errorCode));
return;
}
length = udatpg_getBestPattern(dtpg, testSkeleton1, 4,
bestPattern, 20, &errorCode);
if(U_FAILURE(errorCode)) {
log_err("udatpg_getBestPattern failed - %s\n", u_errorName(errorCode));
return;
}
if((u_memcmp(bestPattern, expectingBestPattern, length)!=0) || bestPattern[length]!=0) {
log_err("udatpg_getBestPattern did not return the expected string\n");
return;
}
/* Test skeleton == NULL */
s=NULL;
length = udatpg_getBestPattern(dtpg, s, 0, bestPattern, 20, &errorCode);
if(!U_FAILURE(errorCode)&&(length!=0) ) {
log_err("udatpg_getBestPattern failed in illegal argument - skeleton is NULL.\n");
return;
}
/* Test udatpg_getSkeleton */
length = udatpg_getSkeleton(dtpg, testPattern, 5, result, 20, &errorCode);
if(U_FAILURE(errorCode)) {
log_err("udatpg_getSkeleton failed - %s\n", u_errorName(errorCode));
return;
}
if((u_memcmp(result, expectingSkeleton, length)!=0) || result[length]!=0) {
log_err("udatpg_getSkeleton did not return the expected string\n");
return;
}
/* Test pattern == NULL */
s=NULL;
length = udatpg_getSkeleton(dtpg, s, 0, result, 20, &errorCode);
if(!U_FAILURE(errorCode)&&(length!=0) ) {
log_err("udatpg_getSkeleton failed in illegal argument - pattern is NULL.\n");
return;
}
/* Test udatpg_getBaseSkeleton */
length = udatpg_getBaseSkeleton(dtpg, testPattern, 5, result, 20, &errorCode);
if(U_FAILURE(errorCode)) {
log_err("udatpg_getBaseSkeleton failed - %s\n", u_errorName(errorCode));
return;
}
if((u_memcmp(result, expectingBaseSkeleton, length)!=0) || result[length]!=0) {
log_err("udatpg_getBaseSkeleton did not return the expected string\n");
return;
}
/* Test pattern == NULL */
s=NULL;
length = udatpg_getBaseSkeleton(dtpg, s, 0, result, 20, &errorCode);
if(!U_FAILURE(errorCode)&&(length!=0) ) {
log_err("udatpg_getBaseSkeleton failed in illegal argument - pattern is NULL.\n");
return;
}
/* set append format to {1}{0} */
udatpg_setAppendItemFormat( dtpg, UDATPG_MONTH_FIELD, testFormat, 7 );
r = udatpg_getAppendItemFormat(dtpg, UDATPG_MONTH_FIELD, &length);
if(length!=7 || 0!=u_memcmp(r, testFormat, length) || r[length]!=0) {
log_err("udatpg_setAppendItemFormat did not return the expected string\n");
return;
}
for (appItemNameDataPtr = appendItemNameData; appItemNameDataPtr->field < UDATPG_FIELD_COUNT; appItemNameDataPtr++) {
int32_t nameLength;
const UChar * namePtr = udatpg_getAppendItemName(dtpg, appItemNameDataPtr->field, &nameLength);
if ( namePtr == NULL || u_strncmp(appItemNameDataPtr->name, namePtr, nameLength) != 0 ) {
log_err("udatpg_getAppendItemName returns invalid name for field %d\n", (int)appItemNameDataPtr->field);
}
}
/* set append name to hr */
udatpg_setAppendItemName( dtpg, UDATPG_HOUR_FIELD, appendItemName, 7 );
r = udatpg_getAppendItemName(dtpg, UDATPG_HOUR_FIELD, &length);
if(length!=7 || 0!=u_memcmp(r, appendItemName, length) || r[length]!=0) {
log_err("udatpg_setAppendItemName did not return the expected string\n");
return;
}
/* set date time format to {1}{0} */
udatpg_setDateTimeFormat( dtpg, testFormat, 7 );
r = udatpg_getDateTimeFormat(dtpg, &length);
if(length!=7 || 0!=u_memcmp(r, testFormat, length) || r[length]!=0) {
log_err("udatpg_setDateTimeFormat did not return the expected string\n");
return;
}
udatpg_close(dtpg);
}
