/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1997-2004, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
-/********************************************************************************
+/*******************************************************************************
*
* File CALLCOLL.C
*
* Modification History:
* Name Description
* Madhu Katragadda Ported for C API
-*********************************************************************************
+********************************************************************************
*/
/*
#include "unicode/ucol.h"
#include "unicode/uloc.h"
+#include "unicode/ures.h"
+#include "unicode/udata.h"
#include "unicode/ucoleitr.h"
#include "unicode/ustring.h"
#include "unicode/uclean.h"
#include "unicode/putil.h"
+#include "unicode/uenum.h"
#include "cintltst.h"
#include "ccolltst.h"
#include "calldata.h"
#include "cstring.h"
#include "cmemory.h"
-#include "ucol_imp.h"
+
+/* set to 1 to test offsets in backAndForth() */
+#define TEST_OFFSETS 0
/* perform test with strength PRIMARY */
static void TestPrimary(void);
static void TestFCDCrash(void);
+static void TestJ5298(void);
+
const UCollationResult results[] = {
UCOL_LESS,
UCOL_LESS, /*UCOL_GREATER,*/
};
+static
+void uprv_appendByteToHexString(char *dst, uint8_t val) {
+ uint32_t len = (uint32_t)uprv_strlen(dst);
+ *(dst+len) = T_CString_itosOffset((val >> 4));
+ *(dst+len+1) = T_CString_itosOffset((val & 0xF));
+ *(dst+len+2) = 0;
+}
+
+/* this function makes a string with representation of a sortkey */
+static char* U_EXPORT2 sortKeyToString(const UCollator *coll, const uint8_t *sortkey, char *buffer, uint32_t *len) {
+ int32_t strength = UCOL_PRIMARY;
+ uint32_t res_size = 0;
+ UBool doneCase = FALSE;
+ UErrorCode errorCode = U_ZERO_ERROR;
+
+ char *current = buffer;
+ const uint8_t *currentSk = sortkey;
+
+ uprv_strcpy(current, "[");
+
+ while(strength <= UCOL_QUATERNARY && strength <= ucol_getStrength(coll)) {
+ if(strength > UCOL_PRIMARY) {
+ uprv_strcat(current, " . ");
+ }
+ while(*currentSk != 0x01 && *currentSk != 0x00) { /* print a level */
+ uprv_appendByteToHexString(current, *currentSk++);
+ uprv_strcat(current, " ");
+ }
+ if(ucol_getAttribute(coll, UCOL_CASE_LEVEL, &errorCode) == UCOL_ON && strength == UCOL_SECONDARY && doneCase == FALSE) {
+ doneCase = TRUE;
+ } else if(ucol_getAttribute(coll, UCOL_CASE_LEVEL, &errorCode) == UCOL_OFF || doneCase == TRUE || strength != UCOL_SECONDARY) {
+ strength ++;
+ }
+ if (*currentSk) {
+ uprv_appendByteToHexString(current, *currentSk++); /* This should print '01' */
+ }
+ if(strength == UCOL_QUATERNARY && ucol_getAttribute(coll, UCOL_ALTERNATE_HANDLING, &errorCode) == UCOL_NON_IGNORABLE) {
+ break;
+ }
+ }
+
+ if(ucol_getStrength(coll) == UCOL_IDENTICAL) {
+ uprv_strcat(current, " . ");
+ while(*currentSk != 0) {
+ uprv_appendByteToHexString(current, *currentSk++);
+ uprv_strcat(current, " ");
+ }
+
+ uprv_appendByteToHexString(current, *currentSk++);
+ }
+ uprv_strcat(current, "]");
+
+ if(res_size > *len) {
+ return NULL;
+ }
+
+ return buffer;
+}
+
void addAllCollTest(TestNode** root)
{
-
-
addTest(root, &TestPrimary, "tscoll/callcoll/TestPrimary");
addTest(root, &TestSecondary, "tscoll/callcoll/TestSecondary");
addTest(root, &TestTertiary, "tscoll/callcoll/TestTertiary");
addTest(root, &TestIdentical, "tscoll/callcoll/TestIdentical");
addTest(root, &TestExtra, "tscoll/callcoll/TestExtra");
- addTest(root, &TestJB581, "tscoll/callcoll/TestJB581");
- addTest(root, &TestVariableTop, "tscoll/callcoll/TestVariableTop");
+ addTest(root, &TestJB581, "tscoll/callcoll/TestJB581");
+ addTest(root, &TestVariableTop, "tscoll/callcoll/TestVariableTop");
addTest(root, &TestSurrogates, "tscoll/callcoll/TestSurrogates");
addTest(root, &TestInvalidRules, "tscoll/callcoll/TestInvalidRules");
- addTest(root, &TestJB1401, "tscoll/callcoll/TestJB1401");
- addTest(root, &TestJitterbug1098, "tscoll/callcoll/TestJitterbug1098");
+ addTest(root, &TestJB1401, "tscoll/callcoll/TestJB1401");
+ addTest(root, &TestJitterbug1098, "tscoll/callcoll/TestJitterbug1098");
addTest(root, &TestFCDCrash, "tscoll/callcoll/TestFCDCrash");
-
- }
+ addTest(root, &TestJ5298, "tscoll/callcoll/TestJ5298");
+}
UBool hasCollationElements(const char *locName) {
UErrorCode status = U_ZERO_ERROR;
- UResourceBundle *ColEl = NULL;
- UResourceBundle *loc = ures_open(NULL, locName, &status);;
+ UResourceBundle *loc = ures_open(U_ICUDATA_NAME U_TREE_SEPARATOR_STRING "coll", locName, &status);;
if(U_SUCCESS(status)) {
status = U_ZERO_ERROR;
- ColEl = ures_getByKey(loc, "collations", ColEl, &status);
+ loc = ures_getByKey(loc, "collations", loc, &status);
+ ures_close(loc);
if(status == U_ZERO_ERROR) { /* do the test - there are real elements */
- ures_close(ColEl);
- ures_close(loc);
return TRUE;
}
- ures_close(ColEl);
- ures_close(loc);
}
return FALSE;
}
UColAttributeValue norm = ucol_getAttribute(myCollation, UCOL_NORMALIZATION_MODE, &status);
UCharIterator sIter, tIter;
+
+ compareResult = ucol_strcoll(myCollation, source, sLen, target, tLen);
+ if (compareResult != result) {
+ log_err("ucol_strcoll with explicit length returned wrong result (%i exp. %i): %s, %s\n",
+ compareResult, result, aescstrdup(source,-1), aescstrdup(target,-1));
+ }
+ compareResulta = ucol_strcoll(myCollation, source, -1, target, -1);
+ if (compareResulta != result) {
+ log_err("ucol_strcoll with null terminated strings returned wrong result (%i exp. %i): %s, %s\n",
+ compareResult, result, aescstrdup(source,-1), aescstrdup(target,-1));
+ }
+
uiter_setString(&sIter, source, sLen);
uiter_setString(&tIter, target, tLen);
compareResultIter = ucol_strcollIter(myCollation, &sIter, &tIter, &status);
if(compareResultIter != result) {
- log_err("different results in iterative comparison for UTF-16 encoded strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));
+ log_err("different results in iterative comparison for UTF-16 encoded strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));
}
- /* convert the strings to UTF-8 and do try comparing with char iterator */
- if(QUICK <= 0) { /*!QUICK*/
- char utf8Source[256], utf8Target[256];
- int32_t utf8SourceLen = 0, utf8TargetLen = 0;
- u_strToUTF8(utf8Source, 256, &utf8SourceLen, source, sLen, &status);
- if(U_FAILURE(status)) { /* probably buffer is not big enough */
- log_verbose("Src UTF-8 buffer too small! Will not compare!\n");
- } else {
- u_strToUTF8(utf8Target, 256, &utf8TargetLen, target, tLen, &status);
- if(U_SUCCESS(status)) { /* probably buffer is not big enough */
- UCollationResult compareResultUTF8 = result, compareResultUTF8Norm = result;
- /*UCharIterator sIter, tIter;*/
- /*log_verbose("Strings converted to UTF-8:%s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));*/
- uiter_setUTF8(&sIter, utf8Source, utf8SourceLen);
- uiter_setUTF8(&tIter, utf8Target, utf8TargetLen);
- /*uiter_setString(&sIter, source, sLen);
- uiter_setString(&tIter, target, tLen);*/
- compareResultUTF8 = ucol_strcollIter(myCollation, &sIter, &tIter, &status);
- ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
- sIter.move(&sIter, 0, UITER_START);
- tIter.move(&tIter, 0, UITER_START);
- compareResultUTF8Norm = ucol_strcollIter(myCollation, &sIter, &tIter, &status);
- ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, norm, &status);
- if(compareResultUTF8 != compareResultIter) {
- log_err("different results in iterative comparison for UTF-16 and UTF-8 encoded strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));
- }
- if(compareResultUTF8 != compareResultUTF8Norm) {
- log_err("different results in iterative when normalization is turned on with UTF-8 strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));
- }
+ /* convert the strings to UTF-8 and do try comparing with char iterator and ucol_strcollUTF8 */
+ {
+ char utf8Source[256], utf8Target[256];
+ int32_t utf8SourceLen = 0, utf8TargetLen = 0;
+
+ u_strToUTF8(utf8Source, 256, &utf8SourceLen, source, sLen, &status);
+ if(U_FAILURE(status)) { /* probably buffer is not big enough */
+ log_verbose("Src UTF-8 buffer too small! Will not compare!\n");
} else {
- log_verbose("Target UTF-8 buffer too small! Did not compare!\n");
- }
- if(U_FAILURE(status)) {
- log_verbose("UTF-8 strcoll failed! Ignoring result\n");
+ u_strToUTF8(utf8Target, 256, &utf8TargetLen, target, tLen, &status);
+ if(U_SUCCESS(status)) {
+ {
+ /* ucol_strcollUTF8 */
+ compareResulta = ucol_strcollUTF8(myCollation, utf8Source, utf8SourceLen, utf8Target, utf8TargetLen, &status);
+ if (U_FAILURE(status)) {
+ log_err("Error in ucol_strcollUTF8 with explicit length\n");
+ status = U_ZERO_ERROR;
+ } else if (compareResulta != result) {
+ log_err("ucol_strcollUTF8 with explicit length returned wrong result (%i exp. %i): %s, %s\n",
+ compareResulta, result, aescstrdup(source,-1), aescstrdup(target,-1));
+ }
+ compareResulta = ucol_strcollUTF8(myCollation, utf8Source, -1, utf8Target, -1, &status);
+ if (U_FAILURE(status)) {
+ log_err("Error in ucol_strcollUTF8 with null terminated strings\n");
+ status = U_ZERO_ERROR;
+ } else if (compareResulta != result) {
+ log_err("ucol_strcollUTF8 with null terminated strings returned wrong result (%i exp. %i): %s, %s\n",
+ compareResulta, result, aescstrdup(source,-1), aescstrdup(target,-1));
+ }
+ }
+
+ {
+ /* char iterator over UTF8 */
+ UCollationResult compareResultUTF8Iter = result, compareResultUTF8IterNorm = result;
+
+ uiter_setUTF8(&sIter, utf8Source, utf8SourceLen);
+ uiter_setUTF8(&tIter, utf8Target, utf8TargetLen);
+ compareResultUTF8Iter = ucol_strcollIter(myCollation, &sIter, &tIter, &status);
+
+ ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
+ sIter.move(&sIter, 0, UITER_START);
+ tIter.move(&tIter, 0, UITER_START);
+ compareResultUTF8IterNorm = ucol_strcollIter(myCollation, &sIter, &tIter, &status);
+
+ ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, norm, &status);
+ if(compareResultUTF8Iter != compareResultIter) {
+ log_err("different results in iterative comparison for UTF-16 and UTF-8 encoded strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));
+ }
+ if(compareResultUTF8Iter != compareResultUTF8IterNorm) {
+ log_err("different results in iterative when normalization is turned on with UTF-8 strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));
+ }
+ }
+ } else {
+ log_verbose("Target UTF-8 buffer too small! Did not compare!\n");
+ }
+ if(U_FAILURE(status)) {
+ log_verbose("UTF-8 strcoll failed! Ignoring result\n");
+ }
}
- }
}
/* testing the partial sortkeys */
int32_t i = 0;
int32_t partialSizes[] = { 3, 1, 2, 4, 8, 20, 80 }; /* just size 3 in the quick mode */
int32_t partialSizesSize = 1;
- if(QUICK <= 0) {
+ if(getTestOption(QUICK_OPTION) <= 0) {
partialSizesSize = 7;
}
/*log_verbose("partial sortkey test piecesize=");*/
partialSKResult = compareUsingPartials(myCollation, source, sLen, target, tLen, partialSizes[i], &status);
if(partialSKResult != result) {
- log_err("Partial sortkey comparison returned wrong result: %s, %s (size %i)\n",
+ log_err("Partial sortkey comparison returned wrong result (%i exp. %i): %s, %s (size %i)\n",
+ partialSKResult, result,
aescstrdup(source,-1), aescstrdup(target,-1), partialSizes[i]);
}
- if(QUICK <= 0 && norm != UCOL_ON) {
+ if(getTestOption(QUICK_OPTION) <= 0 && norm != UCOL_ON) {
/*log_verbose("N ");*/
ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
partialNormalizedSKResult = compareUsingPartials(myCollation, source, sLen, target, tLen, partialSizes[i], &status);
/*log_verbose("\n");*/
}
-
- compareResult = ucol_strcoll(myCollation, source, sLen, target, tLen);
- compareResulta = ucol_strcoll(myCollation, source, -1, target, -1);
- if (compareResult != compareResulta) {
- log_err("ucol_strcoll result from null terminated and explicit length strings differs.\n");
- }
-
sortklen1=ucol_getSortKey(myCollation, source, sLen, NULL, 0);
sortklen2=ucol_getSortKey(myCollation, target, tLen, NULL, 0);
sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
+ (void)sortklenmin; /* Suppress set but not used warning. */
sortKey1 =(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
sortKey1a=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
gSortklen2 = uprv_strlen((const char *)sortKey2)+1;
if(sortklen1 != gSortklen1){
log_err("SortKey length does not match Expected: %i Got: %i\n",sortklen1, gSortklen1);
- log_verbose("Generated sortkey: %s\n", ucol_sortKeyToString(myCollation, sortKey1, buffer, &len));
+ log_verbose("Generated sortkey: %s\n", sortKeyToString(myCollation, sortKey1, buffer, &len));
}
if(sortklen2!= gSortklen2){
log_err("SortKey length does not match Expected: %i Got: %i\n", sortklen2, gSortklen2);
- log_verbose("Generated sortkey: %s\n", ucol_sortKeyToString(myCollation, sortKey2, buffer, &len));
+ log_verbose("Generated sortkey: %s\n", sortKeyToString(myCollation, sortKey2, buffer, &len));
}
if(temp < 0) {
* Return an integer array containing all of the collation orders
* returned by calls to next on the specified iterator
*/
-int32_t* getOrders(UCollationElements *iter, int32_t *orderLength)
+OrderAndOffset* getOrders(UCollationElements *iter, int32_t *orderLength)
{
UErrorCode status;
int32_t order;
int32_t maxSize = 100;
int32_t size = 0;
- int32_t *temp;
- int32_t *orders =(int32_t*)malloc(sizeof(int32_t) * maxSize);
+ int32_t offset = ucol_getOffset(iter);
+ OrderAndOffset *temp;
+ OrderAndOffset *orders =(OrderAndOffset *)malloc(sizeof(OrderAndOffset) * maxSize);
status= U_ZERO_ERROR;
if (size == maxSize)
{
maxSize *= 2;
- temp = (int32_t*)malloc(sizeof(int32_t) * maxSize);
+ temp = (OrderAndOffset *)malloc(sizeof(OrderAndOffset) * maxSize);
- memcpy(temp, orders, size * sizeof(int32_t));
+ memcpy(temp, orders, size * sizeof(OrderAndOffset));
free(orders);
orders = temp;
}
- orders[size++] = order;
+ orders[size].order = order;
+ orders[size].offset = offset;
+
+ offset = ucol_getOffset(iter);
+ size += 1;
}
if (maxSize > size && size > 0)
{
- temp = (int32_t*)malloc(sizeof(int32_t) * size);
+ temp = (OrderAndOffset *)malloc(sizeof(OrderAndOffset) * size);
- memcpy(temp, orders, size * sizeof(int32_t));
+ memcpy(temp, orders, size * sizeof(OrderAndOffset));
free(orders);
orders = temp;
backAndForth(UCollationElements *iter)
{
/* Run through the iterator forwards and stick it into an array */
- int32_t index, o;
+ int32_t idx, o;
UErrorCode status = U_ZERO_ERROR;
int32_t orderLength = 0;
- int32_t *orders;
- orders= getOrders(iter, &orderLength);
+ OrderAndOffset *orders = getOrders(iter, &orderLength);
/* Now go through it backwards and make sure we get the same values */
- index = orderLength;
+ idx = orderLength;
ucol_reset(iter);
/* synwee : changed */
- while ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER)
- {
- if (o != orders[-- index])
- {
+ while ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER) {
+#if TEST_OFFSETS
+ int32_t offset =
+#endif
+ ucol_getOffset(iter);
+
+ idx -= 1;
+ if (o != orders[idx].order) {
if (o == 0)
- index ++;
- else
- {
- while (index > 0 && orders[-- index] == 0)
- {
+ idx ++;
+ else {
+ while (idx > 0 && orders[-- idx].order == 0) {
+ /* nothing... */
}
- if (o != orders[index])
- {
- log_err("Mismatch at index : 0x%x\n", index);
- return;
- }
+ if (o != orders[idx].order) {
+ log_err("Mismatched order at index %d: 0x%8.8X vs. 0x%8.8X\n", idx,
+ orders[idx].order, o);
+ goto bail;
+ }
}
}
+
+#if TEST_OFFSETS
+ if (offset != orders[idx].offset) {
+ log_err("Mismatched offset at index %d: %d vs. %d\n", idx,
+ orders[idx].offset, offset);
+ goto bail;
+ }
+#endif
+
}
- while (index != 0 && orders[index - 1] == 0) {
- index --;
+ while (idx != 0 && orders[idx - 1].order == 0) {
+ idx -= 1;
}
- if (index != 0)
- {
- log_err("Didn't get back to beginning - index is %d\n", index);
+ if (idx != 0) {
+ log_err("Didn't get back to beginning - index is %d\n", idx);
ucol_reset(iter);
log_err("\nnext: ");
- if ((o = ucol_next(iter, &status)) != UCOL_NULLORDER)
- {
+
+ if ((o = ucol_next(iter, &status)) != UCOL_NULLORDER) {
log_err("Error at %x\n", o);
}
+
log_err("\nprev: ");
- if ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER)
- {
+
+ if ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER) {
log_err("Error at %x\n", o);
}
+
log_verbose("\n");
}
+bail:
free(orders);
}
-void genericOrderingTestWithResult(UCollator *coll, const char *s[], uint32_t size, UCollationResult result) {
+void genericOrderingTestWithResult(UCollator *coll, const char * const s[], uint32_t size, UCollationResult result) {
UChar t1[2048] = {0};
UChar t2[2048] = {0};
UCollationElements *iter;
ucol_closeElements(iter);
}
-void genericOrderingTest(UCollator *coll, const char *s[], uint32_t size) {
+void genericOrderingTest(UCollator *coll, const char * const s[], uint32_t size) {
genericOrderingTestWithResult(coll, s, size, UCOL_LESS);
}
-void genericLocaleStarter(const char *locale, const char *s[], uint32_t size) {
+void genericLocaleStarter(const char *locale, const char * const s[], uint32_t size) {
UErrorCode status = U_ZERO_ERROR;
UCollator *coll = ucol_open(locale, &status);
ucol_close(coll);
}
-void genericLocaleStarterWithResult(const char *locale, const char *s[], uint32_t size, UCollationResult result) {
+void genericLocaleStarterWithResult(const char *locale, const char * const s[], uint32_t size, UCollationResult result) {
UErrorCode status = U_ZERO_ERROR;
UCollator *coll = ucol_open(locale, &status);
ucol_close(coll);
}
-#if 0
/* currently not used with options */
-void genericRulesStarterWithOptions(const char *rules, const char *s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, uint32_t attsize) {
+void genericRulesStarterWithOptionsAndResult(const char *rules, const char * const s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, uint32_t attsize, UCollationResult result) {
UErrorCode status = U_ZERO_ERROR;
UChar rlz[RULE_BUFFER_LEN] = { 0 };
uint32_t rlen = u_unescape(rules, rlz, RULE_BUFFER_LEN);
ucol_setAttribute(coll, attrs[i], values[i], &status);
}
- genericOrderingTest(coll, s, size);
+ genericOrderingTestWithResult(coll, s, size, result);
} else {
- log_err("Unable to open collator with rules %s\n", rules);
+ log_err_status(status, "Unable to open collator with rules %s\n", rules);
}
ucol_close(coll);
}
-#endif
-void genericLocaleStarterWithOptions(const char *locale, const char *s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, uint32_t attsize) {
+void genericLocaleStarterWithOptionsAndResult(const char *locale, const char * const s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, uint32_t attsize, UCollationResult result) {
UErrorCode status = U_ZERO_ERROR;
uint32_t i;
ucol_setAttribute(coll, attrs[i], values[i], &status);
}
- genericOrderingTest(coll, s, size);
+ genericOrderingTestWithResult(coll, s, size, result);
} else {
- log_err("Unable to open collator for locale %s\n", locale);
+ log_err_status(status, "Unable to open collator for locale %s\n", locale);
}
ucol_close(coll);
}
-void genericRulesTestWithResult(const char *rules, const char *s[], uint32_t size, UCollationResult result) {
+void genericLocaleStarterWithOptions(const char *locale, const char * const s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, uint32_t attsize) {
+ genericLocaleStarterWithOptionsAndResult(locale, s, size, attrs, values, attsize, UCOL_LESS);
+}
+
+void genericRulesStarterWithResult(const char *rules, const char * const s[], uint32_t size, UCollationResult result) {
UErrorCode status = U_ZERO_ERROR;
UChar rlz[RULE_BUFFER_LEN] = { 0 };
uint32_t rlen = u_unescape(rules, rlz, RULE_BUFFER_LEN);
}
}
-void genericRulesStarter(const char *rules, const char *s[], uint32_t size) {
- genericRulesTestWithResult(rules, s, size, UCOL_LESS);
+void genericRulesStarter(const char *rules, const char * const s[], uint32_t size) {
+ genericRulesStarterWithResult(rules, s, size, UCOL_LESS);
}
static void TestTertiary()
{
int32_t len,i;
- UChar *rules;
UCollator *myCollation;
UErrorCode status=U_ZERO_ERROR;
- const char* str="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
+ static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
+ UChar rules[sizeof(str)];
len = strlen(str);
- rules=(UChar*)malloc(sizeof(UChar*) * (len+1));
u_uastrcpy(rules, str);
myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH, NULL, &status);
if(U_FAILURE(status)){
- log_err("ERROR: in creation of rule based collator :%s\n", myErrorName(status));
+ log_err_status(status, "ERROR: in creation of rule based collator :%s\n", myErrorName(status));
+ return;
}
ucol_setStrength(myCollation, UCOL_TERTIARY);
{
doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
}
- free(rules);
ucol_close(myCollation);
myCollation = 0;
}
static void TestPrimary( )
{
int32_t len,i;
- UChar *rules;
UCollator *myCollation;
UErrorCode status=U_ZERO_ERROR;
- const char* str="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
+ static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
+ UChar rules[sizeof(str)];
len = strlen(str);
- rules=(UChar*)malloc(sizeof(UChar*) * (len+1));
u_uastrcpy(rules, str);
myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL, &status);
if(U_FAILURE(status)){
- log_err("ERROR: in creation of rule based collator :%s\n", myErrorName(status));
+ log_err_status(status, "ERROR: in creation of rule based collator :%s\n", myErrorName(status));
+ return;
}
ucol_setStrength(myCollation, UCOL_PRIMARY);
doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
}
- free(rules);
ucol_close(myCollation);
myCollation = 0;
}
{
int32_t i;
int32_t len;
- UChar *rules;
UCollator *myCollation;
UErrorCode status=U_ZERO_ERROR;
- const char* str="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
+ static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
+ UChar rules[sizeof(str)];
len = strlen(str);
- rules=(UChar*)malloc(sizeof(UChar*) * (len+1));
u_uastrcpy(rules, str);
myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL, &status);
if(U_FAILURE(status)){
- log_err("ERROR: in creation of rule based collator :%s\n", myErrorName(status));
+ log_err_status(status, "ERROR: in creation of rule based collator :%s\n", myErrorName(status));
+ return;
}
ucol_setStrength(myCollation, UCOL_SECONDARY);
for (i = 26; i < 34 ; i++)
{
doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
}
- free(rules);
ucol_close(myCollation);
myCollation = 0;
}
{
int32_t i;
int32_t len;
- UChar *rules = 0;
UCollator *myCollation;
UErrorCode status=U_ZERO_ERROR;
- const char* str="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
+ static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
+ UChar rules[sizeof(str)];
len = strlen(str);
- rules=(UChar*)malloc(sizeof(UChar*) * (len+1));
u_uastrcpy(rules, str);
myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_IDENTICAL, NULL,&status);
if(U_FAILURE(status)){
- log_err("ERROR: in creation of rule based collator :%s\n", myErrorName(status));
+ log_err_status(status, "ERROR: in creation of rule based collator :%s\n", myErrorName(status));
+ return;
}
for(i= 34; i<37; i++)
{
doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
}
- free(rules);
ucol_close(myCollation);
myCollation = 0;
}
{
int32_t i, j;
int32_t len;
- UChar *rules;
UCollator *myCollation;
UErrorCode status = U_ZERO_ERROR;
- const char* str="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
+ static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
+ UChar rules[sizeof(str)];
len = strlen(str);
- rules=(UChar*)malloc(sizeof(UChar*) * (len+1));
u_uastrcpy(rules, str);
myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL, &status);
if(U_FAILURE(status)){
- log_err("ERROR: in creation of rule based collator :%s\n", myErrorName(status));
+ log_err_status(status, "ERROR: in creation of rule based collator :%s\n", myErrorName(status));
+ return;
}
ucol_setStrength(myCollation, UCOL_TERTIARY);
for (i = 0; i < COUNT_TEST_CASES-1 ; i++)
doTest(myCollation, testCases[i], testCases[j], UCOL_LESS);
}
}
- free(rules);
ucol_close(myCollation);
myCollation = 0;
}
static void TestJB581(void)
{
- UChar dispName [100];
int32_t bufferLen = 0;
UChar source [100];
UChar target [100];
myCollator = ucol_open("en_US", &status);
if (U_FAILURE(status)){
- bufferLen = uloc_getDisplayName("en_US", 0, dispName, 100, &status);
- /*Report the error with display name... */
- log_err("ERROR: Failed to create the collator for : \"%s\"\n", dispName);
+ log_err_status(status, "ERROR: Failed to create the collator : %s\n", u_errorName(status));
return;
}
result = ucol_strcoll(myCollator, source, -1, target, -1);
}
/* Now, do the same comparison with keys */
sourceKeyOut = ucol_getSortKey(myCollator, source, -1, sourceKeyArray, 100);
+ (void)sourceKeyOut; /* Suppress set but not used warning. */
targetKeyOut = ucol_getSortKey(myCollator, target, -1, targetKeyArray, 100);
- result = 0;
bufferLen = ((targetKeyOut > 100) ? 100 : targetKeyOut);
- result = memcmp(sourceKeyArray, targetKeyArray, bufferLen);
- if (result != 0)
+ if (memcmp(sourceKeyArray, targetKeyArray, bufferLen) != 0)
{
log_err("Comparing two strings with sort keys in C failed.\n");
}
myCollator = ucol_open("en_US", &status);
if (U_FAILURE(status)){
- int32_t bufferLen = 0;
- UChar dispName [100];
- bufferLen = uloc_getDisplayName("en_US", 0, dispName, 100, &status);
- /*Report the error with display name... */
- log_err("ERROR: Failed to create the collator for : \"%s\"\n", dispName);
+ log_err_status(status, "ERROR: Failed to create the collator : %s\n", u_errorName(status));
return;
}
ucol_setAttribute(myCollator, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
*/
static void TestVariableTop(void)
{
- const char *str = "&z = [variable top]";
+#if 0
+ /*
+ * Starting with ICU 53, setting the variable top via a pseudo relation string
+ * is not supported any more.
+ * It was replaced by the [maxVariable symbol] setting.
+ * See ICU tickets #9958 and #8032.
+ */
+ static const char str[] = "&z = [variable top]";
int len = strlen(str);
- UChar *rules;
+ UChar rules[sizeof(str)];
UCollator *myCollation;
UCollator *enCollation;
UErrorCode status = U_ZERO_ERROR;
uint8_t result[20];
uint8_t expected[20];
- rules = (UChar*)malloc(sizeof(UChar*) * (len + 1));
u_uastrcpy(rules, str);
enCollation = ucol_open("en_US", &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: in creation of collator :%s\n",
+ myErrorName(status));
+ return;
+ }
myCollation = ucol_openRules(rules, len, UCOL_OFF,
UCOL_PRIMARY,NULL, &status);
if (U_FAILURE(status)) {
+ ucol_close(enCollation);
log_err("ERROR: in creation of rule based collator :%s\n",
myErrorName(status));
return;
ch ++;
}
- free(rules);
ucol_close(enCollation);
ucol_close(myCollation);
enCollation = NULL;
myCollation = NULL;
+#endif
}
/**
*/
static void TestSurrogates(void)
{
- const char *str =
+ static const char str[] =
"&z<'\\uD800\\uDC00'<'\\uD800\\uDC0A\\u0308'<A";
int len = strlen(str);
int rlen = 0;
- UChar *rules;
+ UChar rules[sizeof(str)];
UCollator *myCollation;
UCollator *enCollation;
UErrorCode status = U_ZERO_ERROR;
int enlen, mylen;
/* tests for open rules with surrogate rules */
- rules = (UChar*)malloc(sizeof(UChar*) * (len + 1));
rlen = u_unescape(str, rules, len);
enCollation = ucol_open("en_US", &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: in creation of collator :%s\n",
+ myErrorName(status));
+ return;
+ }
myCollation = ucol_openRules(rules, rlen, UCOL_OFF,
UCOL_TERTIARY,NULL, &status);
if (U_FAILURE(status)) {
+ ucol_close(enCollation);
log_err("ERROR: in creation of rule based collator :%s\n",
myErrorName(status));
return;
log_verbose("Failed : non-tailored supplementary characters should have the same value\n");
}
- free(rules);
ucol_close(enCollation);
ucol_close(myCollation);
enCollation = NULL;
"& C < ch, cH, & Ch[variable top]"
};
static const char* preContextArr[MAX_ERROR_STATES] = {
- "his should fail",
- "& C < ch, cH, ",
+ " C < ch, cH, Ch",
+ "& C < ch, cH",
};
static const char* postContextArr[MAX_ERROR_STATES] = {
- "<d",
- " Ch[variable t"
+ "[this should fa",
+ ", & Ch[variable"
};
int i;
u_memset(parseError.postContext,0x0000,U_PARSE_CONTEXT_LEN);
/* open the rules and test */
coll = ucol_openRules(rules,u_strlen(rules),UCOL_OFF,UCOL_DEFAULT_STRENGTH,&parseError,&status);
+ (void)coll; /* Suppress set but not used warning. */
if(u_strcmp(parseError.preContext,preContextExp)!=0){
- log_err("preContext in UParseError for ucol_openRules does not match\n");
+ log_err_status(status, "preContext in UParseError for ucol_openRules does not match: \"%s\"\n",
+ aescstrdup(parseError.preContext, -1));
}
if(u_strcmp(parseError.postContext,postContextExp)!=0){
- log_err("postContext in UParseError for ucol_openRules does not match\n");
+ log_err_status(status, "postContext in UParseError for ucol_openRules does not match: \"%s\"\n",
+ aescstrdup(parseError.postContext, -1));
}
}
}
"&\\'<\\\\",
"&\\\"<'\\'",
"&'\"'<\\'",
- '\0'
+ NULL
};
const UCollationResult results1098[] = {
u_uastrcpy(rule, rules[i]);
c1 = ucol_openRules(rule, u_strlen(rule), UCOL_OFF, UCOL_DEFAULT_STRENGTH, &parseError, &status);
if(U_FAILURE(status)){
- log_err("Could not parse the rules syntax. Error: %s ", u_errorName(status));
+ log_err_status(status, "Could not parse the rules syntax. Error: %s\n", u_errorName(status));
if (status == U_PARSE_ERROR) {
u_UCharsToChars(parseError.preContext,preContext,20);
}
}
-/* These tests do cleanup and reinitialize ICU in the course of their operation.
- * The ICU data directory must be preserved across these operations.
- * Here is a helper function to assist with that.
- */
-static char *safeGetICUDataDirectory() {
- const char *dataDir = u_getDataDirectory(); /* Returned string vanashes with u_cleanup */
- char *retStr = NULL;
- if (dataDir != NULL) {
- retStr = (char *)malloc(strlen(dataDir)+1);
- strcpy(retStr, dataDir);
- }
- return retStr;
-}
-
-
static void
TestFCDCrash(void) {
static const char *test[] = {
"Grossist"
};
- char *icuDataDir = safeGetICUDataDirectory();
UErrorCode status = U_ZERO_ERROR;
UCollator *coll = ucol_open("es", &status);
if(U_FAILURE(status)) {
- log_err("Couldn't open collator\n");
+ log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status));
return;
}
ucol_close(coll);
coll = NULL;
- u_cleanup();
- u_setDataDirectory(icuDataDir);
+ ctest_resetICU();
coll = ucol_open("de_DE", &status);
if(U_FAILURE(status)) {
- log_err("Couldn't open collator\n");
+ log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status));
return;
}
ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
genericOrderingTest(coll, test, 2);
ucol_close(coll);
- free(icuDataDir);
-
}
+/*static UBool
+find(UEnumeration* list, const char* str, UErrorCode* status){
+ const char* value = NULL;
+ int32_t length=0;
+ if(U_FAILURE(*status)){
+ return FALSE;
+ }
+ uenum_reset(list, status);
+ while( (value= uenum_next(list, &length, status))!=NULL){
+ if(strcmp(value, str)==0){
+ return TRUE;
+ }
+ }
+ return FALSE;
+}*/
+
+static void TestJ5298(void)
+{
+ UErrorCode status = U_ZERO_ERROR;
+ char input[256], output[256];
+ UBool isAvailable;
+ int32_t i = 0;
+ UEnumeration* values = NULL;
+ const char *keywordValue = NULL;
+ log_verbose("Number of collator locales returned : %i \n", ucol_countAvailable());
+ values = ucol_getKeywordValues("collation", &status);
+ while ((keywordValue = uenum_next(values, NULL, &status)) != NULL) {
+ if (strncmp(keywordValue, "private-", 8) == 0) {
+ log_err("ucol_getKeywordValues() returns private collation keyword: %s\n", keywordValue);
+ }
+ }
+ for (i = 0; i < ucol_countAvailable(); i++) {
+ uenum_reset(values, &status);
+ while ((keywordValue = uenum_next(values, NULL, &status)) != NULL) {
+ strcpy(input, ucol_getAvailable(i));
+ if (strcmp(keywordValue, "standard") != 0) {
+ strcat(input, "@collation=");
+ strcat(input, keywordValue);
+ }
+
+ ucol_getFunctionalEquivalent(output, 256, "collation", input, &isAvailable, &status);
+ if (strcmp(input, output) == 0) { /* Unique locale, print it out */
+ log_verbose("%s, \n", output);
+ }
+ }
+ }
+ uenum_close(values);
+ log_verbose("\n");
+}
#endif /* #if !UCONFIG_NO_COLLATION */
projects / apple / icu.git / blobdiff