+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 2001-2004, International Business Machines Corporation and
+ * Copyright (c) 2001-2016, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
/*******************************************************************************
#include "unicode/ustring.h"
#include "string.h"
#include "ucol_imp.h"
-#include "ucol_tok.h"
#include "cmemory.h"
#include "cstring.h"
#include "uassert.h"
#include "unicode/parseerr.h"
#include "unicode/ucnv.h"
+#include "unicode/ures.h"
+#include "unicode/uscript.h"
+#include "unicode/utf16.h"
#include "uparse.h"
+#include "putilimp.h"
-#define LEN(a) (sizeof(a)/sizeof(a[0]))
#define MAX_TOKEN_LEN 16
-typedef int tst_strcoll(void *collator, const int object,
+typedef UCollationResult tst_strcoll(void *collator, const int object,
const UChar *source, const int sLen,
const UChar *target, const int tLen);
coll = ucol_openRules(temp, u_strlen(temp), UCOL_OFF, UCOL_DEFAULT_STRENGTH, NULL,&status);
if(U_SUCCESS(status)) {
- size = sizeof(cnt1)/sizeof(cnt1[0]);
+ size = UPRV_LENGTHOF(cnt1);
for(i = 0; i < size-1; i++) {
for(j = i+1; j < size; j++) {
UCollationElements *iter;
coll = ucol_openRules(temp, u_strlen(temp), UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL, &status);
if(U_SUCCESS(status)) {
- size = sizeof(cnt2)/sizeof(cnt2[0]);
+ size = UPRV_LENGTHOF(cnt2);
for(i = 0; i < size-1; i++) {
for(j = i+1; j < size; j++) {
UCollationElements *iter;
};
const static UCollationResult shiftedTert[] = {
- 0,
+ UCOL_EQUAL,
UCOL_EQUAL,
UCOL_EQUAL,
UCOL_LESS,
ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, &status);
if(U_SUCCESS(status)) {
- size = sizeof(nonignorable)/sizeof(nonignorable[0]);
+ size = UPRV_LENGTHOF(nonignorable);
for(i = 0; i < size-1; i++) {
for(j = i+1; j < size; j++) {
u_uastrcpy(t1, nonignorable[i]);
ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_QUATERNARY, &status);
if(U_SUCCESS(status)) {
- size = sizeof(shifted)/sizeof(shifted[0]);
+ size = UPRV_LENGTHOF(shifted);
for(i = 0; i < size-1; i++) {
for(j = i+1; j < size; j++) {
u_uastrcpy(t1, shifted[i]);
ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_TERTIARY, &status);
if(U_SUCCESS(status)) {
- size = sizeof(shifted)/sizeof(shifted[0]);
+ size = UPRV_LENGTHOF(shifted);
for(i = 1; i < size; i++) {
u_uastrcpy(t1, shifted[i-1]);
u_uastrcpy(t2, shifted[i]);
UCollator *myCollation;
myCollation = ucol_open("en_US", &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;
}
log_verbose("Testing some A letters, for some reason\n");
}
fprintf(stderr, "\n");
- for(h = 0; h<sizeof(caseFirst)/sizeof(caseFirst[0]); h++) {
+ for(h = 0; h<UPRV_LENGTHOF(caseFirst); h++) {
ucol_setAttribute(coll, UCOL_CASE_FIRST, caseFirst[i], &status);
fprintf(stderr, "caseFirst: %s\n", caseFirstC[h]);
- for(i = 0; i<sizeof(alternateHandling)/sizeof(alternateHandling[0]); i++) {
+ for(i = 0; i<UPRV_LENGTHOF(alternateHandling); i++) {
ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, alternateHandling[i], &status);
fprintf(stderr, " AltHandling: %s\n", alternateHandlingC[i]);
- for(j = 0; j<sizeof(caseLevel)/sizeof(caseLevel[0]); j++) {
+ for(j = 0; j<UPRV_LENGTHOF(caseLevel); j++) {
ucol_setAttribute(coll, UCOL_CASE_LEVEL, caseLevel[j], &status);
fprintf(stderr, " caseLevel: %s\n", caseLevelC[j]);
- for(k = 0; k<sizeof(strengths)/sizeof(strengths[0]); k++) {
+ for(k = 0; k<UPRV_LENGTHOF(strengths); k++) {
ucol_setAttribute(coll, UCOL_STRENGTH, strengths[k], &status);
sortkeysize = ucol_getSortKey(coll, m, sizem, sortkey, 256);
fprintf(stderr, " strength: %s\n Sortkey: ", strengthsC[k]);
if (lr) {
cr = ures_getByKey(lr,"collations",0,&lec);
if (cr) {
- lp = ures_getLocale(cr,&lec);
+ lp = ures_getLocaleByType(cr, ULOC_ACTUAL_LOCALE, &lec);
if (lp) {
if (U_SUCCESS(lec)) {
if(strcmp(lp, "fr") != 0) {
}
}
-static void testPrimary(UCollator* col, const UChar* p,const UChar* q){
- UChar source[256] = { '\0'};
- UChar target[256] = { '\0'};
- UChar preP = 0x31a3;
- UChar preQ = 0x310d;
-/*
- UChar preP = (*p>0x0400 && *p<0x0500)?0x00e1:0x491;
- UChar preQ = (*p>0x0400 && *p<0x0500)?0x0041:0x413;
-*/
- /*log_verbose("Testing primary\n");*/
+const static char chTest[][20] = {
+ "c",
+ "C",
+ "ca", "cb", "cx", "cy", "CZ",
+ "c\\u030C", "C\\u030C",
+ "h",
+ "H",
+ "ha", "Ha", "harly", "hb", "HB", "hx", "HX", "hy", "HY",
+ "ch", "cH", "Ch", "CH",
+ "cha", "charly", "che", "chh", "chch", "chr",
+ "i", "I", "iarly",
+ "r", "R",
+ "r\\u030C", "R\\u030C",
+ "s",
+ "S",
+ "s\\u030C", "S\\u030C",
+ "z", "Z",
+ "z\\u030C", "Z\\u030C"
+};
- doTest(col, p, q, UCOL_LESS);
-/*
- UCollationResult result = ucol_strcoll(col,p,u_strlen(p),q,u_strlen(q));
+static void TestChMove(void) {
+ UChar t1[256] = {0};
+ UChar t2[256] = {0};
+
+ uint32_t i = 0, j = 0;
+ uint32_t size = 0;
+ UErrorCode status = U_ZERO_ERROR;
+
+ UCollator *coll = ucol_open("cs", &status);
- if(result!=UCOL_LESS){
- aescstrdup(p,utfSource,256);
- aescstrdup(q,utfTarget,256);
- fprintf(file,"Primary failed source: %s target: %s \n", utfSource,utfTarget);
+ if(U_SUCCESS(status)) {
+ size = UPRV_LENGTHOF(chTest);
+ for(i = 0; i < size-1; i++) {
+ for(j = i+1; j < size; j++) {
+ u_unescape(chTest[i], t1, 256);
+ u_unescape(chTest[j], t2, 256);
+ doTest(coll, t1, t2, UCOL_LESS);
+ }
+ }
}
-*/
- source[0] = preP;
- u_strcpy(source+1,p);
- target[0] = preQ;
- u_strcpy(target+1,q);
- doTest(col, source, target, UCOL_LESS);
-/*
- fprintf(file,"Primary swamps 2nd failed source: %s target: %s \n", utfSource,utfTarget);
-*/
+ else {
+ log_data_err("Can't open collator");
+ }
+ ucol_close(coll);
}
-static void testSecondary(UCollator* col, const UChar* p,const UChar* q){
- UChar source[256] = { '\0'};
- UChar target[256] = { '\0'};
- /*log_verbose("Testing secondary\n");*/
- doTest(col, p, q, UCOL_LESS);
-/*
- fprintf(file,"secondary failed source: %s target: %s \n", utfSource,utfTarget);
-*/
- source[0] = 0x0053;
- u_strcpy(source+1,p);
- target[0]= 0x0073;
- u_strcpy(target+1,q);
- doTest(col, source, target, UCOL_LESS);
/*
- fprintf(file,"secondary swamps 3rd failed source: %s target: %s \n",utfSource,utfTarget);
+const static char impTest[][20] = {
+ "\\u4e00",
+ "a",
+ "A",
+ "b",
+ "B",
+ "\\u4e01"
+};
*/
- u_strcpy(source,p);
- source[u_strlen(p)] = 0x62;
- source[u_strlen(p)+1] = 0;
-
+static void TestImplicitTailoring(void) {
+ static const struct {
+ const char *rules;
+ const char *data[10];
+ const uint32_t len;
+ } tests[] = {
+ {
+ /* Tailor b and c before U+4E00. */
+ "&[before 1]\\u4e00 < b < c "
+ /* Now, before U+4E00 is c; put d and e after that. */
+ "&[before 1]\\u4e00 < d < e",
+ { "b", "c", "d", "e", "\\u4e00"}, 5 },
+ { "&\\u4e00 < a <<< A < b <<< B", { "\\u4e00", "a", "A", "b", "B", "\\u4e01"}, 6 },
+ { "&[before 1]\\u4e00 < \\u4e01 < \\u4e02", { "\\u4e01", "\\u4e02", "\\u4e00"}, 3},
+ { "&[before 1]\\u4e01 < \\u4e02 < \\u4e03", { "\\u4e02", "\\u4e03", "\\u4e01"}, 3}
+ };
- u_strcpy(target,q);
- target[u_strlen(q)] = 0x61;
- target[u_strlen(q)+1] = 0;
+ int32_t i = 0;
- doTest(col, source, target, UCOL_GREATER);
+ for(i = 0; i < UPRV_LENGTHOF(tests); i++) {
+ genericRulesStarter(tests[i].rules, tests[i].data, tests[i].len);
+ }
/*
- fprintf(file,"secondary is swamped by 1 failed source: %s target: %s \n",utfSource,utfTarget);
-*/
-}
+ UChar t1[256] = {0};
+ UChar t2[256] = {0};
-static void testTertiary(UCollator* col, const UChar* p,const UChar* q){
- UChar source[256] = { '\0'};
- UChar target[256] = { '\0'};
+ const char *rule = "&\\u4e00 < a <<< A < b <<< B";
- /*log_verbose("Testing tertiary\n");*/
+ uint32_t i = 0, j = 0;
+ uint32_t size = 0;
+ uint32_t ruleLen = 0;
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *coll = NULL;
+ ruleLen = u_unescape(rule, t1, 256);
- doTest(col, p, q, UCOL_LESS);
-/*
- fprintf(file,"Tertiary failed source: %s target: %s \n",utfSource,utfTarget);
-*/
- source[0] = 0x0020;
- u_strcpy(source+1,p);
- target[0]= 0x002D;
- u_strcpy(target+1,q);
+ coll = ucol_openRules(t1, ruleLen, UCOL_OFF, UCOL_TERTIARY,NULL, &status);
- doTest(col, source, target, UCOL_LESS);
-/*
- fprintf(file,"Tertiary swamps 4th failed source: %s target: %s \n", utfSource,utfTarget);
-*/
+ if(U_SUCCESS(status)) {
+ size = UPRV_LENGTHOF(impTest);
+ for(i = 0; i < size-1; i++) {
+ for(j = i+1; j < size; j++) {
+ u_unescape(impTest[i], t1, 256);
+ u_unescape(impTest[j], t2, 256);
+ doTest(coll, t1, t2, UCOL_LESS);
+ }
+ }
+ }
+ else {
+ log_err("Can't open collator");
+ }
+ ucol_close(coll);
+ */
+}
+
+static void TestFCDProblem(void) {
+ UChar t1[256] = {0};
+ UChar t2[256] = {0};
+
+ const char *s1 = "\\u0430\\u0306\\u0325";
+ const char *s2 = "\\u04D1\\u0325";
- u_strcpy(source,p);
- source[u_strlen(p)] = 0xE0;
- source[u_strlen(p)+1] = 0;
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *coll = ucol_open("", &status);
+ u_unescape(s1, t1, 256);
+ u_unescape(s2, t2, 256);
- u_strcpy(target,q);
- target[u_strlen(q)] = 0x61;
- target[u_strlen(q)+1] = 0;
+ ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_OFF, &status);
+ doTest(coll, t1, t2, UCOL_EQUAL);
- doTest(col, source, target, UCOL_GREATER);
+ ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
+ doTest(coll, t1, t2, UCOL_EQUAL);
-/*
- fprintf(file,"Tertiary is swamped by 3rd failed source: %s target: %s \n",utfSource,utfTarget);
-*/
+ ucol_close(coll);
}
-static void testEquality(UCollator* col, const UChar* p,const UChar* q){
/*
- UChar source[256] = { '\0'};
- UChar target[256] = { '\0'};
+The largest normalization form is 18 for NFKC/NFKD, 4 for NFD and 3 for NFC
+We're only using NFC/NFD in this test.
*/
+#define NORM_BUFFER_TEST_LEN 18
+typedef struct {
+ UChar32 u;
+ UChar NFC[NORM_BUFFER_TEST_LEN];
+ UChar NFD[NORM_BUFFER_TEST_LEN];
+} tester;
- doTest(col, p, q, UCOL_EQUAL);
-/*
- fprintf(file,"Primary failed source: %s target: %s \n", utfSource,utfTarget);
-*/
-}
+static void TestComposeDecompose(void) {
+ /* [[:NFD_Inert=false:][:NFC_Inert=false:]] */
+ static const UChar UNICODESET_STR[] = {
+ 0x5B,0x5B,0x3A,0x4E,0x46,0x44,0x5F,0x49,0x6E,0x65,0x72,0x74,0x3D,0x66,0x61,
+ 0x6C,0x73,0x65,0x3A,0x5D,0x5B,0x3A,0x4E,0x46,0x43,0x5F,0x49,0x6E,0x65,0x72,
+ 0x74,0x3D,0x66,0x61,0x6C,0x73,0x65,0x3A,0x5D,0x5D,0
+ };
+ int32_t noOfLoc;
+ int32_t i = 0, j = 0;
-static void testCollator(UCollator *coll, UErrorCode *status) {
- const UChar *rules = NULL, *current = NULL;
- int32_t ruleLen = 0;
- uint32_t strength = 0;
- uint32_t chOffset = 0; uint32_t chLen = 0;
- uint32_t exOffset = 0; uint32_t exLen = 0;
- uint32_t prefixOffset = 0; uint32_t prefixLen = 0;
- uint32_t firstEx = 0;
-/* uint32_t rExpsLen = 0; */
- uint32_t firstLen = 0;
- UBool varT = FALSE; UBool top_ = TRUE;
- uint16_t specs = 0;
- UBool startOfRules = TRUE;
- UBool lastReset = FALSE;
- UBool before = FALSE;
- uint32_t beforeStrength = 0;
- UColTokenParser src;
- UColOptionSet opts;
-
- UChar first[256];
- UChar second[256];
- UChar tempB[256];
- uint32_t tempLen;
- UChar *rulesCopy = NULL;
- UParseError parseError;
- src.opts = &opts;
-
- rules = ucol_getRules(coll, &ruleLen);
- if(U_SUCCESS(*status) && ruleLen > 0) {
- rulesCopy = (UChar *)malloc((ruleLen+UCOL_TOK_EXTRA_RULE_SPACE_SIZE)*sizeof(UChar));
- uprv_memcpy(rulesCopy, rules, ruleLen*sizeof(UChar));
- src.current = src.source = rulesCopy;
- src.end = rulesCopy+ruleLen;
- src.extraCurrent = src.end;
- src.extraEnd = src.end+UCOL_TOK_EXTRA_RULE_SPACE_SIZE;
- *first = *second = 0;
-
- while ((current = ucol_tok_parseNextToken(&src, startOfRules,&parseError, status)) != NULL) {
- strength = src.parsedToken.strength;
- chOffset = src.parsedToken.charsOffset;
- chLen = src.parsedToken.charsLen;
- exOffset = src.parsedToken.extensionOffset;
- exLen = src.parsedToken.extensionLen;
- prefixOffset = src.parsedToken.prefixOffset;
- prefixLen = src.parsedToken.prefixLen;
- specs = src.parsedToken.flags;
-
- startOfRules = FALSE;
- varT = (UBool)((specs & UCOL_TOK_VARIABLE_TOP) != 0);
- top_ = (UBool)((specs & UCOL_TOK_TOP) != 0);
- if(top_) { /* if reset is on top, the sequence is broken. We should have an empty string */
- second[0] = 0;
- } else {
- u_strncpy(second,rulesCopy+chOffset, chLen);
- second[chLen] = 0;
-
- if(exLen > 0 && firstEx == 0) {
- u_strncat(first, rulesCopy+exOffset, exLen);
- first[firstLen+exLen] = 0;
- }
+ UErrorCode status = U_ZERO_ERROR;
+ const char *locName = NULL;
+ uint32_t nfcSize;
+ uint32_t nfdSize;
+ tester **t;
+ uint32_t noCases = 0;
+ UCollator *coll = NULL;
+ UChar32 u = 0;
+ UChar comp[NORM_BUFFER_TEST_LEN];
+ uint32_t len = 0;
+ UCollationElements *iter;
+ USet *charsToTest = uset_openPattern(UNICODESET_STR, -1, &status);
+ int32_t charsToTestSize;
- if(lastReset == TRUE && prefixLen != 0) {
- u_strncpy(first+prefixLen, first, firstLen);
- u_strncpy(first, rulesCopy+prefixOffset, prefixLen);
- first[firstLen+prefixLen] = 0;
- firstLen = firstLen+prefixLen;
- }
+ noOfLoc = uloc_countAvailable();
- if(before == TRUE) { /* swap first and second */
- u_strcpy(tempB, first);
- u_strcpy(first, second);
- u_strcpy(second, tempB);
+ coll = ucol_open("", &status);
+ if (U_FAILURE(status)) {
+ log_data_err("Error opening collator -> %s (Are you missing data?)\n", u_errorName(status));
+ uset_close(charsToTest);
+ return;
+ }
+ charsToTestSize = uset_size(charsToTest);
+ if (charsToTestSize <= 0) {
+ log_err("Set was zero. Missing data?\n");
+ uset_close(charsToTest);
+ return;
+ }
+ t = (tester **)malloc(charsToTestSize * sizeof(tester *));
+ t[0] = (tester *)malloc(sizeof(tester));
+ log_verbose("Testing UCA extensively for %d characters\n", charsToTestSize);
- tempLen = firstLen;
- firstLen = chLen;
- chLen = tempLen;
+ for(u = 0; u < charsToTestSize; u++) {
+ UChar32 ch = uset_charAt(charsToTest, u);
+ len = 0;
+ U16_APPEND_UNSAFE(comp, len, ch);
+ nfcSize = unorm_normalize(comp, len, UNORM_NFC, 0, t[noCases]->NFC, NORM_BUFFER_TEST_LEN, &status);
+ nfdSize = unorm_normalize(comp, len, UNORM_NFD, 0, t[noCases]->NFD, NORM_BUFFER_TEST_LEN, &status);
- tempLen = firstEx;
- firstEx = exLen;
- exLen = tempLen;
- if(beforeStrength < strength) {
- strength = beforeStrength;
- }
+ if(nfcSize != nfdSize || (uprv_memcmp(t[noCases]->NFC, t[noCases]->NFD, nfcSize * sizeof(UChar)) != 0)
+ || (len != nfdSize || (uprv_memcmp(comp, t[noCases]->NFD, nfdSize * sizeof(UChar)) != 0))) {
+ t[noCases]->u = ch;
+ if(len != nfdSize || (uprv_memcmp(comp, t[noCases]->NFD, nfdSize * sizeof(UChar)) != 0)) {
+ u_strncpy(t[noCases]->NFC, comp, len);
+ t[noCases]->NFC[len] = 0;
+ }
+ noCases++;
+ t[noCases] = (tester *)malloc(sizeof(tester));
+ uprv_memset(t[noCases], 0, sizeof(tester));
}
- }
- lastReset = FALSE;
+ }
+ log_verbose("Testing %d/%d of possible test cases\n", noCases, charsToTestSize);
+ uset_close(charsToTest);
+ charsToTest = NULL;
- switch(strength){
- case UCOL_IDENTICAL:
- testEquality(coll,first,second);
- break;
- case UCOL_PRIMARY:
- testPrimary(coll,first,second);
- break;
- case UCOL_SECONDARY:
- testSecondary(coll,first,second);
- break;
- case UCOL_TERTIARY:
- testTertiary(coll,first,second);
- break;
- case UCOL_TOK_RESET:
- lastReset = TRUE;
- before = (UBool)((specs & UCOL_TOK_BEFORE) != 0);
- if(before) {
- beforeStrength = (specs & UCOL_TOK_BEFORE)-1;
+ for(u=0; u<(UChar32)noCases; u++) {
+ if(!ucol_equal(coll, t[u]->NFC, -1, t[u]->NFD, -1)) {
+ log_err("Failure: codePoint %05X fails TestComposeDecompose in the UCA\n", t[u]->u);
+ doTest(coll, t[u]->NFC, t[u]->NFD, UCOL_EQUAL);
}
- break;
- default:
- break;
- }
-
- if(before == TRUE && strength != UCOL_TOK_RESET) { /* first and second were swapped */
- before = FALSE;
- } else {
- firstLen = chLen;
- firstEx = exLen;
- u_strcpy(first, second);
+ }
+ /*
+ for(u = 0; u < charsToTestSize; u++) {
+ if(!(u&0xFFFF)) {
+ log_verbose("%08X ", u);
}
+ uprv_memset(t[noCases], 0, sizeof(tester));
+ t[noCases]->u = u;
+ len = 0;
+ U16_APPEND_UNSAFE(comp, len, u);
+ comp[len] = 0;
+ nfcSize = unorm_normalize(comp, len, UNORM_NFC, 0, t[noCases]->NFC, NORM_BUFFER_TEST_LEN, &status);
+ nfdSize = unorm_normalize(comp, len, UNORM_NFD, 0, t[noCases]->NFD, NORM_BUFFER_TEST_LEN, &status);
+ doTest(coll, comp, t[noCases]->NFD, UCOL_EQUAL);
+ doTest(coll, comp, t[noCases]->NFC, UCOL_EQUAL);
}
- free(rulesCopy);
- }
-}
+ */
-static int ucaTest(void *collator, const int object, const UChar *source, const int sLen, const UChar *target, const int tLen) {
- UCollator *UCA = (UCollator *)collator;
- return ucol_strcoll(UCA, source, sLen, target, tLen);
-}
+ ucol_close(coll);
-/*
-static int winTest(void *collator, const int object, const UChar *source, const int sLen, const UChar *target, const int tLen) {
-#ifdef WIN32
- LCID lcid = (LCID)collator;
- return CompareString(lcid, 0, source, sLen, target, tLen);
-#else
- return 0;
-#endif
-}
-*/
+ log_verbose("Testing locales, number of cases = %i\n", noCases);
+ for(i = 0; i<noOfLoc; i++) {
+ status = U_ZERO_ERROR;
+ locName = uloc_getAvailable(i);
+ if(hasCollationElements(locName)) {
+ char cName[256];
+ UChar name[256];
+ int32_t nameSize = uloc_getDisplayName(locName, NULL, name, sizeof(cName), &status);
-static UCollationResult swampEarlier(tst_strcoll* func, void *collator, int opts,
- UChar s1, UChar s2,
- const UChar *s, const uint32_t sLen,
- const UChar *t, const uint32_t tLen) {
- UChar source[256] = {0};
- UChar target[256] = {0};
+ for(j = 0; j<nameSize; j++) {
+ cName[j] = (char)name[j];
+ }
+ cName[nameSize] = 0;
+ log_verbose("\nTesting locale %s (%s)\n", locName, cName);
- source[0] = s1;
- u_strcpy(source+1, s);
- target[0] = s2;
- u_strcpy(target+1, t);
+ coll = ucol_open(locName, &status);
+ ucol_setStrength(coll, UCOL_IDENTICAL);
+ iter = ucol_openElements(coll, t[u]->NFD, u_strlen(t[u]->NFD), &status);
- return func(collator, opts, source, sLen+1, target, tLen+1);
+ for(u=0; u<(UChar32)noCases; u++) {
+ if(!ucol_equal(coll, t[u]->NFC, -1, t[u]->NFD, -1)) {
+ log_err("Failure: codePoint %05X fails TestComposeDecompose for locale %s\n", t[u]->u, cName);
+ doTest(coll, t[u]->NFC, t[u]->NFD, UCOL_EQUAL);
+ log_verbose("Testing NFC\n");
+ ucol_setText(iter, t[u]->NFC, u_strlen(t[u]->NFC), &status);
+ backAndForth(iter);
+ log_verbose("Testing NFD\n");
+ ucol_setText(iter, t[u]->NFD, u_strlen(t[u]->NFD), &status);
+ backAndForth(iter);
+ }
+ }
+ ucol_closeElements(iter);
+ ucol_close(coll);
+ }
+ }
+ for(u = 0; u <= (UChar32)noCases; u++) {
+ free(t[u]);
+ }
+ free(t);
}
-static UCollationResult swampLater(tst_strcoll* func, void *collator, int opts,
- UChar s1, UChar s2,
- const UChar *s, const uint32_t sLen,
- const UChar *t, const uint32_t tLen) {
- UChar source[256] = {0};
- UChar target[256] = {0};
-
- u_strcpy(source, s);
- source[sLen] = s1;
- u_strcpy(target, t);
- target[tLen] = s2;
+static void TestEmptyRule(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ UChar rulez[] = { 0 };
+ UCollator *coll = ucol_openRules(rulez, 0, UCOL_OFF, UCOL_TERTIARY,NULL, &status);
- return func(collator, opts, source, sLen+1, target, tLen+1);
+ ucol_close(coll);
}
-static uint32_t probeStrength(tst_strcoll* func, void *collator, int opts,
- const UChar *s, const uint32_t sLen,
- const UChar *t, const uint32_t tLen,
- UCollationResult result) {
- /*UChar fPrimary = 0x6d;*/
- /*UChar sPrimary = 0x6e;*/
- UChar fSecondary = 0x310d;
- UChar sSecondary = 0x31a3;
- UChar fTertiary = 0x310f;
- UChar sTertiary = 0x31b7;
-
- UCollationResult oposite;
- if(result == UCOL_EQUAL) {
- return UCOL_IDENTICAL;
- } else if(result == UCOL_GREATER) {
- oposite = UCOL_LESS;
- } else {
- oposite = UCOL_GREATER;
+static void TestUCARules(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ UChar b[256];
+ UChar *rules = b;
+ uint32_t ruleLen = 0;
+ UCollator *UCAfromRules = NULL;
+ UCollator *coll = ucol_open("", &status);
+ if(status == U_FILE_ACCESS_ERROR) {
+ log_data_err("Is your data around?\n");
+ return;
+ } else if(U_FAILURE(status)) {
+ log_err("Error opening collator\n");
+ return;
}
+ ruleLen = ucol_getRulesEx(coll, UCOL_FULL_RULES, rules, 256);
- if(swampEarlier(func, collator, opts, sSecondary, fSecondary, s, sLen, t, tLen) == result) {
- return UCOL_PRIMARY;
- } else if((swampEarlier(func, collator, opts, sTertiary, 0x310f, s, sLen, t, tLen) == result) &&
- (swampEarlier(func, collator, opts, 0x310f, sTertiary, s, sLen, t, tLen) == result)) {
- return UCOL_SECONDARY;
- } else if((swampLater(func, collator, opts, sTertiary, fTertiary, s, sLen, t, tLen) == result) &&
- (swampLater(func, collator, opts, fTertiary, sTertiary, s, sLen, t, tLen) == result)) {
- return UCOL_TERTIARY;
- } else if((swampLater(func, collator, opts, sTertiary, 0x310f, s, sLen, t, tLen) == oposite) &&
- (swampLater(func, collator, opts, fTertiary, sTertiary, s, sLen, t, tLen) == oposite)) {
- return UCOL_QUATERNARY;
- } else {
- return UCOL_IDENTICAL;
+ log_verbose("TestUCARules\n");
+ if(ruleLen > 256) {
+ rules = (UChar *)malloc((ruleLen+1)*sizeof(UChar));
+ ruleLen = ucol_getRulesEx(coll, UCOL_FULL_RULES, rules, ruleLen);
}
-}
-
-static char *getRelationSymbol(UCollationResult res, uint32_t strength, char *buffer) {
- uint32_t i = 0;
-
- if(res == UCOL_EQUAL || strength == 0xdeadbeef) {
- buffer[0] = '=';
- buffer[1] = '=';
- buffer[2] = '\0';
- } else if(res == UCOL_GREATER) {
- for(i = 0; i<strength+1; i++) {
- buffer[i] = '>';
- }
- buffer[strength+1] = '\0';
+ log_verbose("Rules length is %d\n", ruleLen);
+ UCAfromRules = ucol_openRules(rules, ruleLen, UCOL_OFF, UCOL_TERTIARY, NULL,&status);
+ if(U_SUCCESS(status)) {
+ ucol_close(UCAfromRules);
} else {
- for(i = 0; i<strength+1; i++) {
- buffer[i] = '<';
- }
- buffer[strength+1] = '\0';
+ log_verbose("Unable to create a collator from UCARules!\n");
+ }
+/*
+ u_unescape(blah, b, 256);
+ ucol_getSortKey(coll, b, 1, res, 256);
+*/
+ ucol_close(coll);
+ if(rules != b) {
+ free(rules);
}
-
- return buffer;
}
-
-static void logFailure (const char *platform, const char *test,
- const UChar *source, const uint32_t sLen,
- const UChar *target, const uint32_t tLen,
- UCollationResult realRes, uint32_t realStrength,
- UCollationResult expRes, uint32_t expStrength, UBool error) {
-
- uint32_t i = 0;
-
- char sEsc[256], s[256], tEsc[256], t[256], b[256], output[512], relation[256];
- static int maxOutputLength = 0;
- int outputLength;
-
- *sEsc = *tEsc = *s = *t = 0;
- if(error == TRUE) {
- log_err("Difference between expected and generated order. Run test with -v for more info\n");
- } else if(VERBOSITY == 0) {
- return;
- }
- for(i = 0; i<sLen; i++) {
- sprintf(b, "%04X", source[i]);
- strcat(sEsc, "\\u");
- strcat(sEsc, b);
- strcat(s, b);
- strcat(s, " ");
- if(source[i] < 0x80) {
- sprintf(b, "(%c)", source[i]);
- strcat(sEsc, b);
- }
- }
- for(i = 0; i<tLen; i++) {
- sprintf(b, "%04X", target[i]);
- strcat(tEsc, "\\u");
- strcat(tEsc, b);
- strcat(t, b);
- strcat(t, " ");
- if(target[i] < 0x80) {
- sprintf(b, "(%c)", target[i]);
- strcat(tEsc, b);
- }
- }
+/* Pinyin tonal order */
/*
- strcpy(output, "[[ ");
- strcat(output, sEsc);
- strcat(output, getRelationSymbol(expRes, expStrength, relation));
- strcat(output, tEsc);
-
- strcat(output, " : ");
-
- strcat(output, sEsc);
- strcat(output, getRelationSymbol(realRes, realStrength, relation));
- strcat(output, tEsc);
- strcat(output, " ]] ");
+ A < .. (\u0101) < .. (\u00e1) < .. (\u01ce) < .. (\u00e0)
+ (w/macron)< (w/acute)< (w/caron)< (w/grave)
+ E < .. (\u0113) < .. (\u00e9) < .. (\u011b) < .. (\u00e8)
+ I < .. (\u012b) < .. (\u00ed) < .. (\u01d0) < .. (\u00ec)
+ O < .. (\u014d) < .. (\u00f3) < .. (\u01d2) < .. (\u00f2)
+ U < .. (\u016b) < .. (\u00fa) < .. (\u01d4) < .. (\u00f9)
+ < .. (\u01d6) < .. (\u01d8) < .. (\u01da) < .. (\u01dc) <
+.. (\u00fc)
- log_verbose("%s", output);
+However, in testing we got the following order:
+ A < .. (\u00e1) < .. (\u00e0) < .. (\u01ce) < .. (\u0101)
+ (w/acute)< (w/grave)< (w/caron)< (w/macron)
+ E < .. (\u00e9) < .. (\u00e8) < .. (\u00ea) < .. (\u011b) <
+.. (\u0113)
+ I < .. (\u00ed) < .. (\u00ec) < .. (\u01d0) < .. (\u012b)
+ O < .. (\u00f3) < .. (\u00f2) < .. (\u01d2) < .. (\u014d)
+ U < .. (\u00fa) < .. (\u00f9) < .. (\u01d4) < .. (\u00fc) <
+.. (\u01d8)
+ < .. (\u01dc) < .. (\u01da) < .. (\u01d6) < .. (\u016b)
*/
-
- strcpy(output, "DIFF: ");
-
- strcat(output, s);
- strcat(output, " : ");
- strcat(output, t);
-
- strcat(output, test);
- strcat(output, ": ");
-
- strcat(output, sEsc);
- strcat(output, getRelationSymbol(expRes, expStrength, relation));
- strcat(output, tEsc);
-
- strcat(output, " ");
-
- strcat(output, platform);
- strcat(output, ": ");
-
- strcat(output, sEsc);
- strcat(output, getRelationSymbol(realRes, realStrength, relation));
- strcat(output, tEsc);
-
- outputLength = strlen(output);
- if(outputLength > maxOutputLength) {
- maxOutputLength = outputLength;
- U_ASSERT(outputLength < sizeof(output));
- }
-
- log_verbose("%s\n", output);
-
+static void TestBefore(void) {
+ const static char *data[] = {
+ "\\u0101", "\\u00e1", "\\u01ce", "\\u00e0", "A",
+ "\\u0113", "\\u00e9", "\\u011b", "\\u00e8", "E",
+ "\\u012b", "\\u00ed", "\\u01d0", "\\u00ec", "I",
+ "\\u014d", "\\u00f3", "\\u01d2", "\\u00f2", "O",
+ "\\u016b", "\\u00fa", "\\u01d4", "\\u00f9", "U",
+ "\\u01d6", "\\u01d8", "\\u01da", "\\u01dc", "\\u00fc"
+ };
+ genericRulesStarter(
+ "&[before 1]a<\\u0101<\\u00e1<\\u01ce<\\u00e0"
+ "&[before 1]e<\\u0113<\\u00e9<\\u011b<\\u00e8"
+ "&[before 1]i<\\u012b<\\u00ed<\\u01d0<\\u00ec"
+ "&[before 1]o<\\u014d<\\u00f3<\\u01d2<\\u00f2"
+ "&[before 1]u<\\u016b<\\u00fa<\\u01d4<\\u00f9"
+ "&u<\\u01d6<\\u01d8<\\u01da<\\u01dc<\\u00fc",
+ data, UPRV_LENGTHOF(data));
}
-/*
-static void printOutRules(const UChar *rules) {
- uint32_t len = u_strlen(rules);
- uint32_t i = 0;
- char toPrint;
- uint32_t line = 0;
-
- fprintf(stdout, "Rules:");
-
- for(i = 0; i<len; i++) {
- if(rules[i]<0x7f && rules[i]>=0x20) {
- toPrint = (char)rules[i];
- if(toPrint == '&') {
- line = 1;
- fprintf(stdout, "\n&");
- } else if(toPrint == ';') {
- fprintf(stdout, "<<");
- line+=2;
- } else if(toPrint == ',') {
- fprintf(stdout, "<<<");
- line+=3;
- } else {
- fprintf(stdout, "%c", toPrint);
- line++;
- }
- } else if(rules[i]<0x3400 || rules[i]>=0xa000) {
- fprintf(stdout, "\\u%04X", rules[i]);
- line+=6;
- }
- if(line>72) {
- fprintf(stdout, "\n");
- line = 0;
- }
- }
+#if 0
+/* superceded by TestBeforePinyin */
+static void TestJ784(void) {
+ const static char *data[] = {
+ "A", "\\u0101", "\\u00e1", "\\u01ce", "\\u00e0",
+ "E", "\\u0113", "\\u00e9", "\\u011b", "\\u00e8",
+ "I", "\\u012b", "\\u00ed", "\\u01d0", "\\u00ec",
+ "O", "\\u014d", "\\u00f3", "\\u01d2", "\\u00f2",
+ "U", "\\u016b", "\\u00fa", "\\u01d4", "\\u00f9",
+ "\\u00fc",
+ "\\u01d6", "\\u01d8", "\\u01da", "\\u01dc"
+ };
+ genericLocaleStarter("zh", data, UPRV_LENGTHOF(data));
+}
+#endif
- log_verbose("\n");
+static void TestUpperCaseFirst(void) {
+ const static char *data[] = {
+ "I",
+ "i",
+ "Y",
+ "y"
+ };
+ genericLocaleStarter("da", data, UPRV_LENGTHOF(data));
+}
+static void TestJ815(void) {
+ const static char *data[] = {
+ "aa",
+ "Aa",
+ "ab",
+ "Ab",
+ "ad",
+ "Ad",
+ "ae",
+ "Ae",
+ "\\u00e6",
+ "\\u00c6",
+ "af",
+ "Af",
+ "b",
+ "B"
+ };
+ genericLocaleStarter("fr", data, UPRV_LENGTHOF(data));
+ genericRulesStarter("[backwards 2]&A<<\\u00e6/e<<<\\u00c6/E", data, UPRV_LENGTHOF(data));
}
-*/
-static uint32_t testSwitch(tst_strcoll* func, void *collator, int opts, uint32_t strength, const UChar *first, const UChar *second, const char* msg, UBool error) {
- uint32_t diffs = 0;
- UCollationResult realResult;
- uint32_t realStrength;
- uint32_t sLen = u_strlen(first);
- uint32_t tLen = u_strlen(second);
+static void TestCase(void)
+{
+ const static UChar gRules[MAX_TOKEN_LEN] =
+ /*" & 0 < 1,\u2461<a,A"*/
+ { 0x0026, 0x0030, 0x003C, 0x0031, 0x002C, 0x2460, 0x003C, 0x0061, 0x002C, 0x0041, 0x0000 };
- realResult = func(collator, opts, first, sLen, second, tLen);
- realStrength = probeStrength(func, collator, opts, first, sLen, second, tLen, realResult);
+ const static UChar testCase[][MAX_TOKEN_LEN] =
+ {
+ /*0*/ {0x0031 /*'1'*/, 0x0061/*'a'*/, 0x0000},
+ /*1*/ {0x0031 /*'1'*/, 0x0041/*'A'*/, 0x0000},
+ /*2*/ {0x2460 /*circ'1'*/, 0x0061/*'a'*/, 0x0000},
+ /*3*/ {0x2460 /*circ'1'*/, 0x0041/*'A'*/, 0x0000}
+ };
- if(strength == UCOL_IDENTICAL && realResult != UCOL_IDENTICAL) {
- logFailure(msg, "tailoring", first, sLen, second, tLen, realResult, realStrength, UCOL_EQUAL, strength, error);
- diffs++;
- } else if(realResult != UCOL_LESS || realStrength != strength) {
- logFailure(msg, "tailoring", first, sLen, second, tLen, realResult, realStrength, UCOL_LESS, strength, error);
- diffs++;
- }
- return diffs;
-}
+ const static UCollationResult caseTestResults[][9] =
+ {
+ { UCOL_LESS, UCOL_LESS, UCOL_LESS, UCOL_EQUAL, UCOL_LESS, UCOL_LESS, UCOL_EQUAL, UCOL_EQUAL, UCOL_LESS },
+ { UCOL_GREATER, UCOL_LESS, UCOL_LESS, UCOL_EQUAL, UCOL_LESS, UCOL_LESS, UCOL_EQUAL, UCOL_EQUAL, UCOL_GREATER },
+ { UCOL_LESS, UCOL_LESS, UCOL_LESS, UCOL_EQUAL, UCOL_GREATER, UCOL_LESS, UCOL_EQUAL, UCOL_EQUAL, UCOL_LESS },
+ { UCOL_GREATER, UCOL_LESS, UCOL_GREATER, UCOL_EQUAL, UCOL_LESS, UCOL_LESS, UCOL_EQUAL, UCOL_EQUAL, UCOL_GREATER }
+ };
+ const static UColAttributeValue caseTestAttributes[][2] =
+ {
+ { UCOL_LOWER_FIRST, UCOL_OFF},
+ { UCOL_UPPER_FIRST, UCOL_OFF},
+ { UCOL_LOWER_FIRST, UCOL_ON},
+ { UCOL_UPPER_FIRST, UCOL_ON}
+ };
+ int32_t i,j,k;
+ UErrorCode status = U_ZERO_ERROR;
+ UCollationElements *iter;
+ UCollator *myCollation;
+ myCollation = ucol_open("en_US", &status);
-static void testAgainstUCA(UCollator *coll, UCollator *UCA, const char *refName, UBool error, UErrorCode *status) {
- const UChar *rules = NULL, *current = NULL;
- int32_t ruleLen = 0;
- uint32_t strength = 0;
- uint32_t chOffset = 0; uint32_t chLen = 0;
- uint32_t exOffset = 0; uint32_t exLen = 0;
- uint32_t prefixOffset = 0; uint32_t prefixLen = 0;
-/* uint32_t rExpsLen = 0; */
- uint32_t firstLen = 0, secondLen = 0;
- UBool varT = FALSE; UBool top_ = TRUE;
- uint16_t specs = 0;
- UBool startOfRules = TRUE;
- UColTokenParser src;
- UColOptionSet opts;
-
- UChar first[256];
- UChar second[256];
- UChar *rulesCopy = NULL;
-
- uint32_t UCAdiff = 0;
- uint32_t Windiff = 1;
- UParseError parseError;
-
- src.opts = &opts;
-
- rules = ucol_getRules(coll, &ruleLen);
-
- /*printOutRules(rules);*/
-
- if(U_SUCCESS(*status) && ruleLen > 0) {
- rulesCopy = (UChar *)malloc((ruleLen+UCOL_TOK_EXTRA_RULE_SPACE_SIZE)*sizeof(UChar));
- uprv_memcpy(rulesCopy, rules, ruleLen*sizeof(UChar));
- src.current = src.source = rulesCopy;
- src.end = rulesCopy+ruleLen;
- src.extraCurrent = src.end;
- src.extraEnd = src.end+UCOL_TOK_EXTRA_RULE_SPACE_SIZE;
- *first = *second = 0;
-
- while ((current = ucol_tok_parseNextToken(&src, startOfRules, &parseError,status)) != NULL) {
- strength = src.parsedToken.strength;
- chOffset = src.parsedToken.charsOffset;
- chLen = src.parsedToken.charsLen;
- exOffset = src.parsedToken.extensionOffset;
- exLen = src.parsedToken.extensionLen;
- prefixOffset = src.parsedToken.prefixOffset;
- prefixLen = src.parsedToken.prefixLen;
- specs = src.parsedToken.flags;
-
- startOfRules = FALSE;
- varT = (UBool)((specs & UCOL_TOK_VARIABLE_TOP) != 0);
- top_ = (UBool)((specs & UCOL_TOK_TOP) != 0);
-
- u_strncpy(second,rulesCopy+chOffset, chLen);
- second[chLen] = 0;
- secondLen = chLen;
-
- if(exLen > 0) {
- u_strncat(first, rulesCopy+exOffset, exLen);
- first[firstLen+exLen] = 0;
- firstLen += exLen;
- }
+ if(U_FAILURE(status)){
+ log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
+ return;
+ }
+ log_verbose("Testing different case settings\n");
+ ucol_setStrength(myCollation, UCOL_TERTIARY);
- if(strength != UCOL_TOK_RESET) {
- if((*first<0x3400 || *first>=0xa000) && (*second<0x3400 || *second>=0xa000)) {
- UCAdiff += testSwitch(&ucaTest, (void *)UCA, 0, strength, first, second, refName, error);
- /*Windiff += testSwitch(&winTest, (void *)lcid, 0, strength, first, second, "Win32");*/
+ for(k = 0; k<4; k++) {
+ ucol_setAttribute(myCollation, UCOL_CASE_FIRST, caseTestAttributes[k][0], &status);
+ ucol_setAttribute(myCollation, UCOL_CASE_LEVEL, caseTestAttributes[k][1], &status);
+ log_verbose("Case first = %d, Case level = %d\n", caseTestAttributes[k][0], caseTestAttributes[k][1]);
+ for (i = 0; i < 3 ; i++) {
+ for(j = i+1; j<4; j++) {
+ doTest(myCollation, testCase[i], testCase[j], caseTestResults[k][3*i+j-1]);
}
}
-
-
- firstLen = chLen;
- u_strcpy(first, second);
-
- }
- if(UCAdiff != 0 && Windiff != 0) {
- log_verbose("\n");
}
- if(UCAdiff == 0) {
- log_verbose("No immediate difference with %s!\n", refName);
- }
- if(Windiff == 0) {
- log_verbose("No immediate difference with Win32!\n");
+ ucol_close(myCollation);
+
+ myCollation = ucol_openRules(gRules, u_strlen(gRules), UCOL_OFF, UCOL_TERTIARY,NULL, &status);
+ if(U_FAILURE(status)){
+ log_err("ERROR: in creation of rule based collator: %s\n", myErrorName(status));
+ return;
}
- free(rulesCopy);
- }
-}
+ log_verbose("Testing different case settings with custom rules\n");
+ ucol_setStrength(myCollation, UCOL_TERTIARY);
-/*
- * Takes two CEs (lead and continuation) and
- * compares them as CEs should be compared:
- * primary vs. primary, secondary vs. secondary
- * tertiary vs. tertiary
- */
-static int32_t compareCEs(uint32_t s1, uint32_t s2,
- uint32_t t1, uint32_t t2) {
- uint32_t s = 0, t = 0;
- if(s1 == t1 && s2 == t2) {
- return 0;
- }
- s = (s1 & 0xFFFF0000)|((s2 & 0xFFFF0000)>>16);
- t = (t1 & 0xFFFF0000)|((t2 & 0xFFFF0000)>>16);
- if(s < t) {
- return -1;
- } else if(s > t) {
- return 1;
- } else {
- s = (s1 & 0x0000FF00) | (s2 & 0x0000FF00)>>8;
- t = (t1 & 0x0000FF00) | (t2 & 0x0000FF00)>>8;
- if(s < t) {
- return -1;
- } else if(s > t) {
- return 1;
- } else {
- s = (s1 & 0x000000FF)<<8 | (s2 & 0x000000FF);
- t = (t1 & 0x000000FF)<<8 | (t2 & 0x000000FF);
- if(s < t) {
- return -1;
- } else {
- return 1;
+ for(k = 0; k<4; k++) {
+ ucol_setAttribute(myCollation, UCOL_CASE_FIRST, caseTestAttributes[k][0], &status);
+ ucol_setAttribute(myCollation, UCOL_CASE_LEVEL, caseTestAttributes[k][1], &status);
+ for (i = 0; i < 3 ; i++) {
+ for(j = i+1; j<4; j++) {
+ log_verbose("k:%d, i:%d, j:%d\n", k, i, j);
+ doTest(myCollation, testCase[i], testCase[j], caseTestResults[k][3*i+j-1]);
+ iter=ucol_openElements(myCollation, testCase[i], u_strlen(testCase[i]), &status);
+ backAndForth(iter);
+ ucol_closeElements(iter);
+ iter=ucol_openElements(myCollation, testCase[j], u_strlen(testCase[j]), &status);
+ backAndForth(iter);
+ ucol_closeElements(iter);
+ }
}
}
- }
-}
+ ucol_close(myCollation);
+ {
+ const static char *lowerFirst[] = {
+ "h",
+ "H",
+ "ch",
+ "Ch",
+ "CH",
+ "cha",
+ "chA",
+ "Cha",
+ "ChA",
+ "CHa",
+ "CHA",
+ "i",
+ "I"
+ };
+
+ const static char *upperFirst[] = {
+ "H",
+ "h",
+ "CH",
+ "Ch",
+ "ch",
+ "CHA",
+ "CHa",
+ "ChA",
+ "Cha",
+ "chA",
+ "cha",
+ "I",
+ "i"
+ };
+ log_verbose("mixed case test\n");
+ log_verbose("lower first, case level off\n");
+ genericRulesStarter("[caseFirst lower]&H<ch<<<Ch<<<CH", lowerFirst, UPRV_LENGTHOF(lowerFirst));
+ log_verbose("upper first, case level off\n");
+ genericRulesStarter("[caseFirst upper]&H<ch<<<Ch<<<CH", upperFirst, UPRV_LENGTHOF(upperFirst));
+ log_verbose("lower first, case level on\n");
+ genericRulesStarter("[caseFirst lower][caseLevel on]&H<ch<<<Ch<<<CH", lowerFirst, UPRV_LENGTHOF(lowerFirst));
+ log_verbose("upper first, case level on\n");
+ genericRulesStarter("[caseFirst upper][caseLevel on]&H<ch<<<Ch<<<CH", upperFirst, UPRV_LENGTHOF(upperFirst));
+ }
-typedef struct {
- uint32_t startCE;
- uint32_t startContCE;
- uint32_t limitCE;
- uint32_t limitContCE;
-} indirectBoundaries;
-
-/* these values are used for finding CE values for indirect positioning. */
-/* Indirect positioning is a mechanism for allowing resets on symbolic */
-/* values. It only works for resets and you cannot tailor indirect names */
-/* An indirect name can define either an anchor point or a range. An */
-/* anchor point behaves in exactly the same way as a code point in reset */
-/* would, except that it cannot be tailored. A range (we currently only */
-/* know for the [top] range will explicitly set the upper bound for */
-/* generated CEs, thus allowing for better control over how many CEs can */
-/* be squeezed between in the range without performance penalty. */
-/* In that respect, we use [top] for tailoring of locales that use CJK */
-/* characters. Other indirect values are currently a pure convenience, */
-/* they can be used to assure that the CEs will be always positioned in */
-/* the same place relative to a point with known properties (e.g. first */
-/* primary ignorable). */
-static indirectBoundaries ucolIndirectBoundaries[15];
-static UBool indirectBoundariesSet = FALSE;
-static void setIndirectBoundaries(uint32_t indexR, uint32_t *start, uint32_t *end) {
-
- /* Set values for the top - TODO: once we have values for all the indirects, we are going */
- /* to initalize here. */
- ucolIndirectBoundaries[indexR].startCE = start[0];
- ucolIndirectBoundaries[indexR].startContCE = start[1];
- if(end) {
- ucolIndirectBoundaries[indexR].limitCE = end[0];
- ucolIndirectBoundaries[indexR].limitContCE = end[1];
- } else {
- ucolIndirectBoundaries[indexR].limitCE = 0;
- ucolIndirectBoundaries[indexR].limitContCE = 0;
- }
}
-static void testCEs(UCollator *coll, UErrorCode *status) {
-
- const UChar *rules = NULL, *current = NULL;
- int32_t ruleLen = 0;
-
- uint32_t strength = 0;
- uint32_t maxStrength = UCOL_IDENTICAL;
- uint32_t baseCE, baseContCE, nextCE, nextContCE, currCE, currContCE;
- uint32_t lastCE;
- uint32_t lastContCE;
-
- int32_t result = 0;
- uint32_t chOffset = 0; uint32_t chLen = 0;
- uint32_t exOffset = 0; uint32_t exLen = 0;
- uint32_t prefixOffset = 0; uint32_t prefixLen = 0;
- uint32_t oldOffset = 0;
-
- /* uint32_t rExpsLen = 0; */
- /* uint32_t firstLen = 0; */
- uint16_t specs = 0;
- UBool varT = FALSE; UBool top_ = TRUE;
- UBool startOfRules = TRUE;
- UBool before = FALSE;
- UColTokenParser src;
- UColOptionSet opts;
- UParseError parseError;
- UChar *rulesCopy = NULL;
- collIterate c;
- UCollator *UCA = ucol_open("root", status);
- UCAConstants *consts = (UCAConstants *)((uint8_t *)UCA->image + UCA->image->UCAConsts);
- uint32_t UCOL_RESET_TOP_VALUE = consts->UCA_LAST_NON_VARIABLE[0], /*UCOL_RESET_TOP_CONT = consts->UCA_LAST_NON_VARIABLE[1], */
- UCOL_NEXT_TOP_VALUE = consts->UCA_FIRST_IMPLICIT[0], UCOL_NEXT_TOP_CONT = consts->UCA_FIRST_IMPLICIT[1];
-
- baseCE=baseContCE=nextCE=nextContCE=currCE=currContCE=lastCE=lastContCE = UCOL_NOT_FOUND;
-
- src.opts = &opts;
-
- rules = ucol_getRules(coll, &ruleLen);
-
- src.invUCA = ucol_initInverseUCA(status);
-
- if(indirectBoundariesSet == FALSE) {
- /* UCOL_RESET_TOP_VALUE */
- setIndirectBoundaries(0, consts->UCA_LAST_NON_VARIABLE, consts->UCA_FIRST_IMPLICIT);
- /* UCOL_FIRST_PRIMARY_IGNORABLE */
- setIndirectBoundaries(1, consts->UCA_FIRST_PRIMARY_IGNORABLE, 0);
- /* UCOL_LAST_PRIMARY_IGNORABLE */
- setIndirectBoundaries(2, consts->UCA_LAST_PRIMARY_IGNORABLE, 0);
- /* UCOL_FIRST_SECONDARY_IGNORABLE */
- setIndirectBoundaries(3, consts->UCA_FIRST_SECONDARY_IGNORABLE, 0);
- /* UCOL_LAST_SECONDARY_IGNORABLE */
- setIndirectBoundaries(4, consts->UCA_LAST_SECONDARY_IGNORABLE, 0);
- /* UCOL_FIRST_TERTIARY_IGNORABLE */
- setIndirectBoundaries(5, consts->UCA_FIRST_TERTIARY_IGNORABLE, 0);
- /* UCOL_LAST_TERTIARY_IGNORABLE */
- setIndirectBoundaries(6, consts->UCA_LAST_TERTIARY_IGNORABLE, 0);
- /* UCOL_FIRST_VARIABLE */
- setIndirectBoundaries(7, consts->UCA_FIRST_VARIABLE, 0);
- /* UCOL_LAST_VARIABLE */
- setIndirectBoundaries(8, consts->UCA_LAST_VARIABLE, 0);
- /* UCOL_FIRST_NON_VARIABLE */
- setIndirectBoundaries(9, consts->UCA_FIRST_NON_VARIABLE, 0);
- /* UCOL_LAST_NON_VARIABLE */
- setIndirectBoundaries(10, consts->UCA_LAST_NON_VARIABLE, consts->UCA_FIRST_IMPLICIT);
- /* UCOL_FIRST_IMPLICIT */
- setIndirectBoundaries(11, consts->UCA_FIRST_IMPLICIT, 0);
- /* UCOL_LAST_IMPLICIT */
- setIndirectBoundaries(12, consts->UCA_LAST_IMPLICIT, consts->UCA_FIRST_TRAILING);
- /* UCOL_FIRST_TRAILING */
- setIndirectBoundaries(13, consts->UCA_FIRST_TRAILING, 0);
- /* UCOL_LAST_TRAILING */
- setIndirectBoundaries(14, consts->UCA_LAST_TRAILING, 0);
- ucolIndirectBoundaries[14].limitCE = (consts->UCA_PRIMARY_SPECIAL_MIN<<24);
- indirectBoundariesSet = TRUE;
- }
+static void TestIncrementalNormalize(void) {
+
+ /*UChar baseA =0x61;*/
+ UChar baseA =0x41;
+/* UChar baseB = 0x42;*/
+ static const UChar ccMix[] = {0x316, 0x321, 0x300};
+ /*UChar ccMix[] = {0x61, 0x61, 0x61};*/
+ /*
+ 0x316 is combining grave accent below, cc=220
+ 0x321 is combining palatalized hook below, cc=202
+ 0x300 is combining grave accent, cc=230
+ */
+#define MAXSLEN 2000
+ /*int maxSLen = 64000;*/
+ int sLen;
+ int i;
- if(U_SUCCESS(*status) && ruleLen > 0) {
- rulesCopy = (UChar *)malloc((ruleLen+UCOL_TOK_EXTRA_RULE_SPACE_SIZE)*sizeof(UChar));
- uprv_memcpy(rulesCopy, rules, ruleLen*sizeof(UChar));
- src.current = src.source = rulesCopy;
- src.end = rulesCopy+ruleLen;
- src.extraCurrent = src.end;
- src.extraEnd = src.end+UCOL_TOK_EXTRA_RULE_SPACE_SIZE;
-
- while ((current = ucol_tok_parseNextToken(&src, startOfRules, &parseError,status)) != NULL) {
- strength = src.parsedToken.strength;
- chOffset = src.parsedToken.charsOffset;
- chLen = src.parsedToken.charsLen;
- exOffset = src.parsedToken.extensionOffset;
- exLen = src.parsedToken.extensionLen;
- prefixOffset = src.parsedToken.prefixOffset;
- prefixLen = src.parsedToken.prefixLen;
- specs = src.parsedToken.flags;
-
- startOfRules = FALSE;
- varT = (UBool)((specs & UCOL_TOK_VARIABLE_TOP) != 0);
- top_ = (UBool)((specs & UCOL_TOK_TOP) != 0);
-
- uprv_init_collIterate(coll, rulesCopy+chOffset, chLen, &c);
-
- currCE = ucol_getNextCE(coll, &c, status);
- if(currCE == 0 && UCOL_ISTHAIPREVOWEL(*(rulesCopy+chOffset))) {
- log_verbose("Thai prevowel detected. Will pick next CE\n");
- currCE = ucol_getNextCE(coll, &c, status);
- }
+ UCollator *coll;
+ UErrorCode status = U_ZERO_ERROR;
+ UCollationResult result;
- currContCE = ucol_getNextCE(coll, &c, status);
- if(!isContinuation(currContCE)) {
- currContCE = 0;
- }
+ int32_t myQ = getTestOption(QUICK_OPTION);
- /* we need to repack CEs here */
+ if(getTestOption(QUICK_OPTION) < 0) {
+ setTestOption(QUICK_OPTION, 1);
+ }
- if(strength == UCOL_TOK_RESET) {
- before = (UBool)((specs & UCOL_TOK_BEFORE) != 0);
- if(top_ == TRUE) {
- int32_t index = src.parsedToken.indirectIndex;
+ {
+ /* Test 1. Run very long unnormalized strings, to force overflow of*/
+ /* most buffers along the way.*/
+ UChar strA[MAXSLEN+1];
+ UChar strB[MAXSLEN+1];
- nextCE = baseCE = currCE = ucolIndirectBoundaries[index].startCE;
- nextContCE = baseContCE = currContCE = ucolIndirectBoundaries[index].startContCE;
- } else {
- nextCE = baseCE = currCE;
- nextContCE = baseContCE = currContCE;
- }
- maxStrength = UCOL_IDENTICAL;
- } else {
- if(strength < maxStrength) {
- maxStrength = strength;
- if(baseCE == UCOL_RESET_TOP_VALUE) {
- log_verbose("Resetting to [top]\n");
- nextCE = UCOL_NEXT_TOP_VALUE;
- nextContCE = UCOL_NEXT_TOP_CONT;
- } else {
- result = ucol_inv_getNextCE(&src, baseCE & 0xFFFFFF3F, baseContCE, &nextCE, &nextContCE, maxStrength);
- }
- if(result < 0) {
- if(ucol_isTailored(coll, *(rulesCopy+oldOffset), status)) {
- log_verbose("Reset is tailored codepoint %04X, don't know how to continue, taking next test\n", *(rulesCopy+oldOffset));
- return;
- } else {
- log_err("couldn't find the CE\n");
- return;
- }
- }
+ coll = ucol_open("en_US", &status);
+ if(status == U_FILE_ACCESS_ERROR) {
+ log_data_err("Is your data around?\n");
+ return;
+ } else if(U_FAILURE(status)) {
+ log_err("Error opening collator\n");
+ return;
}
+ ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
- currCE &= 0xFFFFFF3F;
- currContCE &= 0xFFFFFFBF;
-
- if(maxStrength == UCOL_IDENTICAL) {
- if(baseCE != currCE || baseContCE != currContCE) {
- log_err("current CE (initial strength UCOL_EQUAL)\n");
- }
- } else {
- if(strength == UCOL_IDENTICAL) {
- if(lastCE != currCE || lastContCE != currContCE) {
- log_err("current CE (initial strength UCOL_EQUAL)\n");
- }
- } else {
- if(compareCEs(currCE, currContCE, nextCE, nextContCE) > 0) {
- /*if(currCE > nextCE || (currCE == nextCE && currContCE >= nextContCE)) {*/
- log_err("current CE is not less than base CE\n");
- }
- if(!before) {
- if(compareCEs(currCE, currContCE, lastCE, lastContCE) < 0) {
- /*if(currCE < lastCE || (currCE == lastCE && currContCE <= lastContCE)) {*/
- log_err("sequence of generated CEs is broken\n");
- }
- } else {
- before = FALSE;
- if(compareCEs(currCE, currContCE, lastCE, lastContCE) > 0) {
- /*if(currCE < lastCE || (currCE == lastCE && currContCE <= lastContCE)) {*/
- log_err("sequence of generated CEs is broken\n");
- }
+ /*for (sLen = 257; sLen<MAXSLEN; sLen++) {*/
+ /*for (sLen = 4; sLen<MAXSLEN; sLen++) {*/
+ /*for (sLen = 1000; sLen<1001; sLen++) {*/
+ for (sLen = 500; sLen<501; sLen++) {
+ /*for (sLen = 40000; sLen<65000; sLen+=1000) {*/
+ strA[0] = baseA;
+ strB[0] = baseA;
+ for (i=1; i<=sLen-1; i++) {
+ strA[i] = ccMix[i % 3];
+ strB[sLen-i] = ccMix[i % 3];
}
- }
+ strA[sLen] = 0;
+ strB[sLen] = 0;
+
+ ucol_setStrength(coll, UCOL_TERTIARY); /* Do test with default strength, which runs*/
+ doTest(coll, strA, strB, UCOL_EQUAL); /* optimized functions in the impl*/
+ ucol_setStrength(coll, UCOL_IDENTICAL); /* Do again with the slow, general impl.*/
+ doTest(coll, strA, strB, UCOL_EQUAL);
}
+ }
+
+ setTestOption(QUICK_OPTION, myQ);
- }
- oldOffset = chOffset;
- lastCE = currCE & 0xFFFFFF3F;
- lastContCE = currContCE & 0xFFFFFFBF;
+ /* Test 2: Non-normal sequence in a string that extends to the last character*/
+ /* of the string. Checks a couple of edge cases.*/
+
+ {
+ static const UChar strA[] = {0x41, 0x41, 0x300, 0x316, 0};
+ static const UChar strB[] = {0x41, 0xc0, 0x316, 0};
+ ucol_setStrength(coll, UCOL_TERTIARY);
+ doTest(coll, strA, strB, UCOL_EQUAL);
}
- free(rulesCopy);
- }
- ucol_close(UCA);
-}
-#if 0
-/* these locales are now picked from index RB */
-static const char* localesToTest[] = {
-"ar", "bg", "ca", "cs", "da",
-"el", "en_BE", "en_US_POSIX",
-"es", "et", "fi", "fr", "hi",
-"hr", "hu", "is", "iw", "ja",
-"ko", "lt", "lv", "mk", "mt",
-"nb", "nn", "nn_NO", "pl", "ro",
-"ru", "sh", "sk", "sl", "sq",
-"sr", "sv", "th", "tr", "uk",
-"vi", "zh", "zh_TW"
-};
-#endif
+ /* Test 3: Non-normal sequence is terminated by a surrogate pair.*/
-static const char* rulesToTest[] = {
- /* Funky fa rule */
- "&\\u0622 < \\u0627 << \\u0671 < \\u0621",
- /*"& Z < p, P",*/
- /* Cui Mins rules */
- "&[top]<o,O<p,P<q,Q<'?'/u<r,R<u,U", /*"<o,O<p,P<q,Q<r,R<u,U & Qu<'?'",*/
- "&[top]<o,O<p,P<q,Q;'?'/u<r,R<u,U", /*"<o,O<p,P<q,Q<r,R<u,U & Qu;'?'",*/
- "&[top]<o,O<p,P<q,Q,'?'/u<r,R<u,U", /*"<o,O<p,P<q,Q<r,R<u,U&'Qu','?'",*/
- "&[top]<3<4<5<c,C<f,F<m,M<o,O<p,P<q,Q;'?'/u<r,R<u,U", /*"<'?'<3<4<5<a,A<f,F<m,M<o,O<p,P<q,Q<r,R<u,U & Qu;'?'",*/
- "&[top]<'?';Qu<3<4<5<c,C<f,F<m,M<o,O<p,P<q,Q<r,R<u,U", /*"<'?'<3<4<5<a,A<f,F<m,M<o,O<p,P<q,Q<r,R<u,U & '?';Qu",*/
- "&[top]<3<4<5<c,C<f,F<m,M<o,O<p,P<q,Q;'?'/um<r,R<u,U", /*"<'?'<3<4<5<a,A<f,F<m,M<o,O<p,P<q,Q<r,R<u,U & Qum;'?'",*/
- "&[top]<'?';Qum<3<4<5<c,C<f,F<m,M<o,O<p,P<q,Q<r,R<u,U" /*"<'?'<3<4<5<a,A<f,F<m,M<o,O<p,P<q,Q<r,R<u,U & '?';Qum"*/
-};
+ {
+ /* New UCA 3.1.1.
+ * test below used a code point from Desseret, which sorts differently
+ * than d800 dc00
+ */
+ /*UChar strA[] = {0x41, 0x41, 0x300, 0x316, 0xD801, 0xDC00, 0};*/
+ static const UChar strA[] = {0x41, 0x41, 0x300, 0x316, 0xD800, 0xDC01, 0};
+ static const UChar strB[] = {0x41, 0xc0, 0x316, 0xD800, 0xDC00, 0};
+ ucol_setStrength(coll, UCOL_TERTIARY);
+ doTest(coll, strA, strB, UCOL_GREATER);
+ }
+ /* Test 4: Imbedded nulls do not terminate a string when length is specified.*/
-static void TestCollations(void) {
- int32_t noOfLoc = uloc_countAvailable();
- int32_t i = 0, j = 0;
+ {
+ static const UChar strA[] = {0x41, 0x00, 0x42, 0x00};
+ static const UChar strB[] = {0x41, 0x00, 0x00, 0x00};
+ char sortKeyA[50];
+ char sortKeyAz[50];
+ char sortKeyB[50];
+ char sortKeyBz[50];
+ int r;
- UErrorCode status = U_ZERO_ERROR;
- char cName[256];
- UChar name[256];
- int32_t nameSize;
+ /* there used to be -3 here. Hmmmm.... */
+ /*result = ucol_strcoll(coll, strA, -3, strB, -3);*/
+ result = ucol_strcoll(coll, strA, 3, strB, 3);
+ if (result != UCOL_GREATER) {
+ log_err("ERROR 1 in test 4\n");
+ }
+ result = ucol_strcoll(coll, strA, -1, strB, -1);
+ if (result != UCOL_EQUAL) {
+ log_err("ERROR 2 in test 4\n");
+ }
+ ucol_getSortKey(coll, strA, 3, (uint8_t *)sortKeyA, sizeof(sortKeyA));
+ ucol_getSortKey(coll, strA, -1, (uint8_t *)sortKeyAz, sizeof(sortKeyAz));
+ ucol_getSortKey(coll, strB, 3, (uint8_t *)sortKeyB, sizeof(sortKeyB));
+ ucol_getSortKey(coll, strB, -1, (uint8_t *)sortKeyBz, sizeof(sortKeyBz));
- const char *locName = NULL;
- UCollator *coll = NULL;
- UCollator *UCA = ucol_open("", &status);
- UColAttributeValue oldStrength = ucol_getAttribute(UCA, UCOL_STRENGTH, &status);
- ucol_setAttribute(UCA, UCOL_STRENGTH, UCOL_QUATERNARY, &status);
+ r = strcmp(sortKeyA, sortKeyAz);
+ if (r <= 0) {
+ log_err("Error 3 in test 4\n");
+ }
+ r = strcmp(sortKeyA, sortKeyB);
+ if (r <= 0) {
+ log_err("Error 4 in test 4\n");
+ }
+ r = strcmp(sortKeyAz, sortKeyBz);
+ if (r != 0) {
+ log_err("Error 5 in test 4\n");
+ }
- for(i = 0; i<noOfLoc; i++) {
- status = U_ZERO_ERROR;
- locName = uloc_getAvailable(i);
- if(uprv_strcmp("ja", locName) == 0) {
- log_verbose("Don't know how to test prefixes\n");
- continue;
- }
- if(hasCollationElements(locName)) {
- nameSize = uloc_getDisplayName(locName, NULL, name, 256, &status);
- for(j = 0; j<nameSize; j++) {
- cName[j] = (char)name[j];
+ ucol_setStrength(coll, UCOL_IDENTICAL);
+ ucol_getSortKey(coll, strA, 3, (uint8_t *)sortKeyA, sizeof(sortKeyA));
+ ucol_getSortKey(coll, strA, -1, (uint8_t *)sortKeyAz, sizeof(sortKeyAz));
+ ucol_getSortKey(coll, strB, 3, (uint8_t *)sortKeyB, sizeof(sortKeyB));
+ ucol_getSortKey(coll, strB, -1, (uint8_t *)sortKeyBz, sizeof(sortKeyBz));
+
+ r = strcmp(sortKeyA, sortKeyAz);
+ if (r <= 0) {
+ log_err("Error 6 in test 4\n");
}
- cName[nameSize] = 0;
- log_verbose("\nTesting locale %s (%s)\n", locName, cName);
- coll = ucol_open(locName, &status);
- if(U_SUCCESS(status)) {
- testAgainstUCA(coll, UCA, "UCA", FALSE, &status);
- ucol_close(coll);
- } else {
- log_err("Couldn't instantiate collator for locale %s, error: %s\n", locName, u_errorName(status));
- status = U_ZERO_ERROR;
+ r = strcmp(sortKeyA, sortKeyB);
+ if (r <= 0) {
+ log_err("Error 7 in test 4\n");
+ }
+ r = strcmp(sortKeyAz, sortKeyBz);
+ if (r != 0) {
+ log_err("Error 8 in test 4\n");
}
+ ucol_setStrength(coll, UCOL_TERTIARY);
}
- }
- ucol_setAttribute(UCA, UCOL_STRENGTH, oldStrength, &status);
- ucol_close(UCA);
-}
-static void RamsRulesTest(void) {
- UErrorCode status = U_ZERO_ERROR;
- int32_t i = 0;
- UCollator *coll = NULL;
- UChar rule[2048];
- uint32_t ruleLen;
- int32_t noOfLoc = uloc_countAvailable();
- const char *locName = NULL;
- log_verbose("RamsRulesTest\n");
+ /* Test 5: Null characters in non-normal source strings.*/
- for(i = 0; i<noOfLoc; i++) {
- status = U_ZERO_ERROR;
- locName = uloc_getAvailable(i);
- if(hasCollationElements(locName)) {
- if (uprv_strcmp("ja", locName)==0) {
- log_verbose("Don't know how to test Japanese because of prefixes\n");
- continue;
- }
- if (uprv_strcmp("de__PHONEBOOK", locName)==0) {
- log_verbose("Don't know how to test Phonebook because the reset is on an expanding character\n");
- continue;
- }
- log_verbose("Testing locale %s\n", locName);
- coll = ucol_open(locName, &status);
- if(U_SUCCESS(status)) {
- if(coll->image->jamoSpecial == TRUE) {
- log_err("%s has special JAMOs\n", locName);
+ {
+ static const UChar strA[] = {0x41, 0x41, 0x300, 0x316, 0x00, 0x42, 0x00};
+ static const UChar strB[] = {0x41, 0x41, 0x300, 0x316, 0x00, 0x00, 0x00};
+ char sortKeyA[50];
+ char sortKeyAz[50];
+ char sortKeyB[50];
+ char sortKeyBz[50];
+ int r;
+
+ result = ucol_strcoll(coll, strA, 6, strB, 6);
+ if (result != UCOL_GREATER) {
+ log_err("ERROR 1 in test 5\n");
+ }
+ result = ucol_strcoll(coll, strA, -1, strB, -1);
+ if (result != UCOL_EQUAL) {
+ log_err("ERROR 2 in test 5\n");
}
- ucol_setAttribute(coll, UCOL_CASE_FIRST, UCOL_OFF, &status);
- testCollator(coll, &status);
- testCEs(coll, &status);
- ucol_close(coll);
- }
- }
- }
- for(i = 0; i<sizeof(rulesToTest)/sizeof(rulesToTest[0]); i++) {
- log_verbose("Testing rule: %s\n", rulesToTest[i]);
- ruleLen = u_unescape(rulesToTest[i], rule, 2048);
- coll = ucol_openRules(rule, ruleLen, UCOL_OFF, UCOL_TERTIARY, NULL,&status);
- if(U_SUCCESS(status)) {
- testCollator(coll, &status);
- testCEs(coll, &status);
- ucol_close(coll);
- }
- }
+ ucol_getSortKey(coll, strA, 6, (uint8_t *)sortKeyA, sizeof(sortKeyA));
+ ucol_getSortKey(coll, strA, -1, (uint8_t *)sortKeyAz, sizeof(sortKeyAz));
+ ucol_getSortKey(coll, strB, 6, (uint8_t *)sortKeyB, sizeof(sortKeyB));
+ ucol_getSortKey(coll, strB, -1, (uint8_t *)sortKeyBz, sizeof(sortKeyBz));
-}
+ r = strcmp(sortKeyA, sortKeyAz);
+ if (r <= 0) {
+ log_err("Error 3 in test 5\n");
+ }
+ r = strcmp(sortKeyA, sortKeyB);
+ if (r <= 0) {
+ log_err("Error 4 in test 5\n");
+ }
+ r = strcmp(sortKeyAz, sortKeyBz);
+ if (r != 0) {
+ log_err("Error 5 in test 5\n");
+ }
-static void IsTailoredTest(void) {
- UErrorCode status = U_ZERO_ERROR;
- uint32_t i = 0;
- UCollator *coll = NULL;
- UChar rule[2048];
- UChar tailored[2048];
- UChar notTailored[2048];
- uint32_t ruleLen, tailoredLen, notTailoredLen;
+ ucol_setStrength(coll, UCOL_IDENTICAL);
+ ucol_getSortKey(coll, strA, 6, (uint8_t *)sortKeyA, sizeof(sortKeyA));
+ ucol_getSortKey(coll, strA, -1, (uint8_t *)sortKeyAz, sizeof(sortKeyAz));
+ ucol_getSortKey(coll, strB, 6, (uint8_t *)sortKeyB, sizeof(sortKeyB));
+ ucol_getSortKey(coll, strB, -1, (uint8_t *)sortKeyBz, sizeof(sortKeyBz));
- log_verbose("IsTailoredTest\n");
+ r = strcmp(sortKeyA, sortKeyAz);
+ if (r <= 0) {
+ log_err("Error 6 in test 5\n");
+ }
+ r = strcmp(sortKeyA, sortKeyB);
+ if (r <= 0) {
+ log_err("Error 7 in test 5\n");
+ }
+ r = strcmp(sortKeyAz, sortKeyBz);
+ if (r != 0) {
+ log_err("Error 8 in test 5\n");
+ }
+ ucol_setStrength(coll, UCOL_TERTIARY);
+ }
- u_uastrcpy(rule, "&Z < A, B, C;c < d");
- ruleLen = u_strlen(rule);
- u_uastrcpy(tailored, "ABCcd");
- tailoredLen = u_strlen(tailored);
+ /* Test 6: Null character as base of a non-normal combining sequence.*/
- u_uastrcpy(notTailored, "ZabD");
- notTailoredLen = u_strlen(notTailored);
+ {
+ static const UChar strA[] = {0x41, 0x0, 0x300, 0x316, 0x41, 0x302, 0x00};
+ static const UChar strB[] = {0x41, 0x0, 0x302, 0x316, 0x41, 0x300, 0x00};
- coll = ucol_openRules(rule, ruleLen, UCOL_OFF, UCOL_TERTIARY, NULL,&status);
- if(U_SUCCESS(status)) {
- for(i = 0; i<tailoredLen; i++) {
- if(!ucol_isTailored(coll, tailored[i], &status)) {
- log_err("%i: %04X should be tailored - it is reported as not\n", i, tailored[i]);
- }
- }
- for(i = 0; i<notTailoredLen; i++) {
- if(ucol_isTailored(coll, notTailored[i], &status)) {
- log_err("%i: %04X should not be tailored - it is reported as it is\n", i, notTailored[i]);
- }
+ result = ucol_strcoll(coll, strA, 5, strB, 5);
+ if (result != UCOL_LESS) {
+ log_err("Error 1 in test 6\n");
+ }
+ result = ucol_strcoll(coll, strA, -1, strB, -1);
+ if (result != UCOL_EQUAL) {
+ log_err("Error 2 in test 6\n");
+ }
}
+
ucol_close(coll);
- }
}
-const static char chTest[][20] = {
- "c",
- "C",
- "ca", "cb", "cx", "cy", "CZ",
- "c\\u030C", "C\\u030C",
- "h",
- "H",
- "ha", "Ha", "harly", "hb", "HB", "hx", "HX", "hy", "HY",
- "ch", "cH", "Ch", "CH",
- "cha", "charly", "che", "chh", "chch", "chr",
- "i", "I", "iarly",
- "r", "R",
- "r\\u030C", "R\\u030C",
- "s",
- "S",
- "s\\u030C", "S\\u030C",
- "z", "Z",
- "z\\u030C", "Z\\u030C"
-};
-static void TestChMove(void) {
- UChar t1[256] = {0};
- UChar t2[256] = {0};
+#if 0
+static void TestGetCaseBit(void) {
+ static const char *caseBitData[] = {
+ "a", "A", "ch", "Ch", "CH",
+ "\\uFF9E", "\\u0009"
+ };
- uint32_t i = 0, j = 0;
- uint32_t size = 0;
- UErrorCode status = U_ZERO_ERROR;
+ static const uint8_t results[] = {
+ UCOL_LOWER_CASE, UCOL_UPPER_CASE, UCOL_LOWER_CASE, UCOL_MIXED_CASE, UCOL_UPPER_CASE,
+ UCOL_UPPER_CASE, UCOL_LOWER_CASE
+ };
- UCollator *coll = ucol_open("cs", &status);
+ uint32_t i, blen = 0;
+ UChar b[256] = {0};
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *UCA = ucol_open("", &status);
+ uint8_t res = 0;
- if(U_SUCCESS(status)) {
- size = sizeof(chTest)/sizeof(chTest[0]);
- for(i = 0; i < size-1; i++) {
- for(j = i+1; j < size; j++) {
- u_unescape(chTest[i], t1, 256);
- u_unescape(chTest[j], t2, 256);
- doTest(coll, t1, t2, UCOL_LESS);
- }
+ for(i = 0; i<UPRV_LENGTHOF(results); i++) {
+ blen = u_unescape(caseBitData[i], b, 256);
+ res = ucol_uprv_getCaseBits(UCA, b, blen, &status);
+ if(results[i] != res) {
+ log_err("Expected case = %02X, got %02X for %04X\n", results[i], res, b[0]);
}
}
- else {
- log_err("Can't open collator");
- }
- ucol_close(coll);
}
+#endif
+static void TestHangulTailoring(void) {
+ static const char *koreanData[] = {
+ "\\uac00", "\\u4f3d", "\\u4f73", "\\u5047", "\\u50f9", "\\u52a0", "\\u53ef", "\\u5475",
+ "\\u54e5", "\\u5609", "\\u5ac1", "\\u5bb6", "\\u6687", "\\u67b6", "\\u67b7", "\\u67ef",
+ "\\u6b4c", "\\u73c2", "\\u75c2", "\\u7a3c", "\\u82db", "\\u8304", "\\u8857", "\\u8888",
+ "\\u8a36", "\\u8cc8", "\\u8dcf", "\\u8efb", "\\u8fe6", "\\u99d5",
+ "\\u4EEE", "\\u50A2", "\\u5496", "\\u54FF", "\\u5777", "\\u5B8A", "\\u659D", "\\u698E",
+ "\\u6A9F", "\\u73C8", "\\u7B33", "\\u801E", "\\u8238", "\\u846D", "\\u8B0C"
+ };
+ const char *rules =
+ "&\\uac00 <<< \\u4f3d <<< \\u4f73 <<< \\u5047 <<< \\u50f9 <<< \\u52a0 <<< \\u53ef <<< \\u5475 "
+ "<<< \\u54e5 <<< \\u5609 <<< \\u5ac1 <<< \\u5bb6 <<< \\u6687 <<< \\u67b6 <<< \\u67b7 <<< \\u67ef "
+ "<<< \\u6b4c <<< \\u73c2 <<< \\u75c2 <<< \\u7a3c <<< \\u82db <<< \\u8304 <<< \\u8857 <<< \\u8888 "
+ "<<< \\u8a36 <<< \\u8cc8 <<< \\u8dcf <<< \\u8efb <<< \\u8fe6 <<< \\u99d5 "
+ "<<< \\u4EEE <<< \\u50A2 <<< \\u5496 <<< \\u54FF <<< \\u5777 <<< \\u5B8A <<< \\u659D <<< \\u698E "
+ "<<< \\u6A9F <<< \\u73C8 <<< \\u7B33 <<< \\u801E <<< \\u8238 <<< \\u846D <<< \\u8B0C";
-const static char impTest[][20] = {
- "\\u4e00",
- "a",
- "A",
- "b",
- "B",
- "\\u4e01"
-};
-
-
-static void TestImplicitTailoring(void) {
- static struct {
- const char *rules;
- const char *data[50];
- const uint32_t len;
- } tests[] = {
- { "&[before 1]\\u4e00 < b < c &[before 1]\\u4e00 < d < e", { "d", "e", "b", "c", "\\u4e00"}, 5 },
- { "&\\u4e00 < a <<< A < b <<< B", { "\\u4e00", "a", "A", "b", "B", "\\u4e01"}, 6 },
- { "&[before 1]\\u4e00 < \\u4e01 < \\u4e02", { "\\u4e01", "\\u4e02", "\\u4e00"}, 3},
- { "&[before 1]\\u4e01 < \\u4e02 < \\u4e03", { "\\u4e02", "\\u4e03", "\\u4e01"}, 3}
- };
-
- int32_t i = 0;
+ UErrorCode status = U_ZERO_ERROR;
+ UChar rlz[2048] = { 0 };
+ uint32_t rlen = u_unescape(rules, rlz, 2048);
- for(i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
- genericRulesStarter(tests[i].rules, tests[i].data, tests[i].len);
+ UCollator *coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &status);
+ if(status == U_FILE_ACCESS_ERROR) {
+ log_data_err("Is your data around?\n");
+ return;
+ } else if(U_FAILURE(status)) {
+ log_err("Error opening collator\n");
+ return;
}
-/*
- UChar t1[256] = {0};
- UChar t2[256] = {0};
-
- const char *rule = "&\\u4e00 < a <<< A < b <<< B";
-
- uint32_t i = 0, j = 0;
- uint32_t size = 0;
- uint32_t ruleLen = 0;
- UErrorCode status = U_ZERO_ERROR;
- UCollator *coll = NULL;
- ruleLen = u_unescape(rule, t1, 256);
-
- coll = ucol_openRules(t1, ruleLen, UCOL_OFF, UCOL_TERTIARY,NULL, &status);
+ log_verbose("Using start of korean rules\n");
if(U_SUCCESS(status)) {
- size = sizeof(impTest)/sizeof(impTest[0]);
- for(i = 0; i < size-1; i++) {
- for(j = i+1; j < size; j++) {
- u_unescape(impTest[i], t1, 256);
- u_unescape(impTest[j], t2, 256);
- doTest(coll, t1, t2, UCOL_LESS);
- }
- }
- }
- else {
- log_err("Can't open collator");
+ genericOrderingTest(coll, koreanData, UPRV_LENGTHOF(koreanData));
+ } else {
+ log_err("Unable to open collator with rules %s\n", rules);
}
- ucol_close(coll);
- */
-}
-
-static void TestFCDProblem(void) {
- UChar t1[256] = {0};
- UChar t2[256] = {0};
-
- const char *s1 = "\\u0430\\u0306\\u0325";
- const char *s2 = "\\u04D1\\u0325";
-
- UErrorCode status = U_ZERO_ERROR;
- UCollator *coll = ucol_open("", &status);
- u_unescape(s1, t1, 256);
- u_unescape(s2, t2, 256);
-
- ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_OFF, &status);
- doTest(coll, t1, t2, UCOL_EQUAL);
-
- ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
- doTest(coll, t1, t2, UCOL_EQUAL);
ucol_close(coll);
-}
-
-#define NORM_BUFFER_TEST_LEN 32
-typedef struct {
- UChar32 u;
- UChar NFC[NORM_BUFFER_TEST_LEN];
- UChar NFD[NORM_BUFFER_TEST_LEN];
-} tester;
-
-static void TestComposeDecompose(void) {
- int32_t noOfLoc;
- int32_t i = 0, j = 0;
-
- UErrorCode status = U_ZERO_ERROR;
- const char *locName = NULL;
+ log_verbose("Using ko__LOTUS locale\n");
+ genericLocaleStarter("ko__LOTUS", koreanData, UPRV_LENGTHOF(koreanData));
+}
- uint32_t nfcSize;
- uint32_t nfdSize;
- tester **t;
- uint32_t noCases = 0;
- UCollator *coll = NULL;
- UChar32 u = 0;
- UChar comp[NORM_BUFFER_TEST_LEN];
- uint32_t len = 0;
- UCollationElements *iter;
+/*
+ * The secondary/tertiary compression middle byte
+ * as used by the current implementation.
+ * Subject to change as the sort key compression changes.
+ * See class CollationKeys.
+ */
+enum {
+ SEC_COMMON_MIDDLE = 0x25, /* range 05..45 */
+ TER_ONLY_COMMON_MIDDLE = 0x65 /* range 05..C5 */
+};
- noOfLoc = uloc_countAvailable();
+static void TestCompressOverlap(void) {
+ UChar secstr[150];
+ UChar tertstr[150];
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *coll;
+ uint8_t result[500];
+ uint32_t resultlen;
+ int count = 0;
+ uint8_t *tempptr;
- t = malloc(0x30000 * sizeof(tester *));
- t[0] = (tester *)malloc(sizeof(tester));
- log_verbose("Testing UCA extensively\n");
coll = ucol_open("", &status);
- if(status == U_FILE_ACCESS_ERROR) {
- log_data_err("Is your data around?\n");
- return;
- } else if(U_FAILURE(status)) {
- log_err("Error opening collator\n");
- return;
+
+ if (U_FAILURE(status)) {
+ log_err_status(status, "Collator can't be created -> %s\n", u_errorName(status));
+ return;
+ }
+ while (count < 149) {
+ secstr[count] = 0x0020; /* [06, 05, 05] */
+ tertstr[count] = 0x0020;
+ count ++;
}
+ /* top down compression ----------------------------------- */
+ secstr[count] = 0x0332; /* [, 87, 05] */
+ tertstr[count] = 0x3000; /* [06, 05, 07] */
- for(u = 0; u < 0x30000; u++) {
- len = 0;
- UTF_APPEND_CHAR_UNSAFE(comp, len, u);
- nfcSize = unorm_normalize(comp, len, UNORM_NFC, 0, t[noCases]->NFC, NORM_BUFFER_TEST_LEN, &status);
- nfdSize = unorm_normalize(comp, len, UNORM_NFD, 0, t[noCases]->NFD, NORM_BUFFER_TEST_LEN, &status);
+ /* no compression secstr should have 150 secondary bytes, tertstr should
+ have 150 tertiary bytes.
+ with correct compression, secstr should have 6 secondary
+ bytes (149/33 rounded up + accent), tertstr should have > 2 tertiary bytes */
+ resultlen = ucol_getSortKey(coll, secstr, 150, result, UPRV_LENGTHOF(result));
+ (void)resultlen; /* Suppress set but not used warning. */
+ tempptr = (uint8_t *)uprv_strchr((char *)result, 1) + 1;
+ while (*(tempptr + 1) != 1) {
+ /* the last secondary collation element is not checked since it is not
+ part of the compression */
+ if (*tempptr < SEC_COMMON_MIDDLE) {
+ log_err("Secondary top down compression overlapped\n");
+ }
+ tempptr ++;
+ }
- if(nfcSize != nfdSize || (uprv_memcmp(t[noCases]->NFC, t[noCases]->NFD, nfcSize * sizeof(UChar)) != 0)
- || (len != nfdSize || (uprv_memcmp(comp, t[noCases]->NFD, nfdSize * sizeof(UChar)) != 0))) {
- t[noCases]->u = u;
- if(len != nfdSize || (uprv_memcmp(comp, t[noCases]->NFD, nfdSize * sizeof(UChar)) != 0)) {
- u_strncpy(t[noCases]->NFC, comp, len);
- t[noCases]->NFC[len] = 0;
- }
- noCases++;
- t[noCases] = (tester *)malloc(sizeof(tester));
- uprv_memset(t[noCases], 0, sizeof(tester));
+ /* tertiary top/bottom/common for en_US is similar to the secondary
+ top/bottom/common */
+ resultlen = ucol_getSortKey(coll, tertstr, 150, result, UPRV_LENGTHOF(result));
+ tempptr = (uint8_t *)uprv_strrchr((char *)result, 1) + 1;
+ while (*(tempptr + 1) != 0) {
+ /* the last secondary collation element is not checked since it is not
+ part of the compression */
+ if (*tempptr < TER_ONLY_COMMON_MIDDLE) {
+ log_err("Tertiary top down compression overlapped\n");
}
+ tempptr ++;
}
- for(u=0; u<(UChar32)noCases; u++) {
- if(!ucol_equal(coll, t[u]->NFC, -1, t[u]->NFD, -1)) {
- log_err("Failure: codePoint %05X fails TestComposeDecompose in the UCA\n", t[u]->u);
- doTest(coll, t[u]->NFC, t[u]->NFD, UCOL_EQUAL);
- }
+ /* bottom up compression ------------------------------------- */
+ secstr[count] = 0;
+ tertstr[count] = 0;
+ resultlen = ucol_getSortKey(coll, secstr, 150, result, UPRV_LENGTHOF(result));
+ tempptr = (uint8_t *)uprv_strchr((char *)result, 1) + 1;
+ while (*(tempptr + 1) != 1) {
+ /* the last secondary collation element is not checked since it is not
+ part of the compression */
+ if (*tempptr > SEC_COMMON_MIDDLE) {
+ log_err("Secondary bottom up compression overlapped\n");
+ }
+ tempptr ++;
}
- /*
- for(u = 0; u < 0x30000; u++) {
- if(!(u&0xFFFF)) {
- log_verbose("%08X ", u);
- }
- uprv_memset(t[noCases], 0, sizeof(tester));
- t[noCases]->u = u;
- len = 0;
- UTF_APPEND_CHAR_UNSAFE(comp, len, u);
- comp[len] = 0;
- nfcSize = unorm_normalize(comp, len, UNORM_NFC, 0, t[noCases]->NFC, NORM_BUFFER_TEST_LEN, &status);
- nfdSize = unorm_normalize(comp, len, UNORM_NFD, 0, t[noCases]->NFD, NORM_BUFFER_TEST_LEN, &status);
- doTest(coll, comp, t[noCases]->NFD, UCOL_EQUAL);
- doTest(coll, comp, t[noCases]->NFC, UCOL_EQUAL);
+
+ /* tertiary top/bottom/common for en_US is similar to the secondary
+ top/bottom/common */
+ resultlen = ucol_getSortKey(coll, tertstr, 150, result, UPRV_LENGTHOF(result));
+ tempptr = (uint8_t *)uprv_strrchr((char *)result, 1) + 1;
+ while (*(tempptr + 1) != 0) {
+ /* the last secondary collation element is not checked since it is not
+ part of the compression */
+ if (*tempptr > TER_ONLY_COMMON_MIDDLE) {
+ log_err("Tertiary bottom up compression overlapped\n");
+ }
+ tempptr ++;
}
- */
ucol_close(coll);
+}
- log_verbose("Testing locales, number of cases = %i\n", noCases);
- for(i = 0; i<noOfLoc; i++) {
- status = U_ZERO_ERROR;
- locName = uloc_getAvailable(i);
- if(hasCollationElements(locName)) {
- char cName[256];
- UChar name[256];
- int32_t nameSize = uloc_getDisplayName(locName, NULL, name, sizeof(cName), &status);
+static void TestCyrillicTailoring(void) {
+ static const char *test[] = {
+ "\\u0410b",
+ "\\u0410\\u0306a",
+ "\\u04d0A"
+ };
- for(j = 0; j<nameSize; j++) {
- cName[j] = (char)name[j];
- }
- cName[nameSize] = 0;
- log_verbose("\nTesting locale %s (%s)\n", locName, cName);
+ /* Russian overrides contractions, so this test is not valid anymore */
+ /*genericLocaleStarter("ru", test, 3);*/
- coll = ucol_open(locName, &status);
- ucol_setStrength(coll, UCOL_IDENTICAL);
- iter = ucol_openElements(coll, t[u]->NFD, u_strlen(t[u]->NFD), &status);
+ // Most of the following are commented out because UCA 8.0
+ // drops most of the Cyrillic contractions from the default order.
+ // See CLDR ticket #7246 "root collation: remove Cyrillic contractions".
- for(u=0; u<(UChar32)noCases; u++) {
- if(!ucol_equal(coll, t[u]->NFC, -1, t[u]->NFD, -1)) {
- log_err("Failure: codePoint %05X fails TestComposeDecompose for locale %s\n", t[u]->u, cName);
- doTest(coll, t[u]->NFC, t[u]->NFD, UCOL_EQUAL);
- log_verbose("Testing NFC\n");
- ucol_setText(iter, t[u]->NFC, u_strlen(t[u]->NFC), &status);
- backAndForth(iter);
- log_verbose("Testing NFD\n");
- ucol_setText(iter, t[u]->NFD, u_strlen(t[u]->NFD), &status);
- backAndForth(iter);
- }
- }
- ucol_closeElements(iter);
- ucol_close(coll);
- }
- }
- for(u = 0; u <= (UChar32)noCases; u++) {
- free(t[u]);
- }
- free(t);
+ // genericLocaleStarter("root", test, 3);
+ // genericRulesStarter("&\\u0410 = \\u0410", test, 3);
+ // genericRulesStarter("&Z < \\u0410", test, 3);
+ genericRulesStarter("&\\u0410 = \\u0410 < \\u04d0", test, 3);
+ genericRulesStarter("&Z < \\u0410 < \\u04d0", test, 3);
+ // genericRulesStarter("&\\u0410 = \\u0410 < \\u0410\\u0301", test, 3);
+ // genericRulesStarter("&Z < \\u0410 < \\u0410\\u0301", test, 3);
}
-static void TestEmptyRule(void) {
- UErrorCode status = U_ZERO_ERROR;
- UChar rulez[] = { 0 };
- UCollator *coll = ucol_openRules(rulez, 0, UCOL_OFF, UCOL_TERTIARY,NULL, &status);
+static void TestSuppressContractions(void) {
- ucol_close(coll);
+ static const char *testNoCont2[] = {
+ "\\u0410\\u0302a",
+ "\\u0410\\u0306b",
+ "\\u0410c"
+ };
+ static const char *testNoCont[] = {
+ "a\\u0410",
+ "A\\u0410\\u0306",
+ "\\uFF21\\u0410\\u0302"
+ };
+
+ genericRulesStarter("[suppressContractions [\\u0400-\\u047f]]", testNoCont, 3);
+ genericRulesStarter("[suppressContractions [\\u0400-\\u047f]]", testNoCont2, 3);
}
-static void TestUCARules(void) {
- UErrorCode status = U_ZERO_ERROR;
- UChar b[256];
- UChar *rules = b;
- uint32_t ruleLen = 0;
- UCollator *UCAfromRules = NULL;
- UCollator *coll = ucol_open("", &status);
- if(status == U_FILE_ACCESS_ERROR) {
- log_data_err("Is your data around?\n");
- return;
- } else if(U_FAILURE(status)) {
- log_err("Error opening collator\n");
+static void TestContraction(void) {
+ const static char *testrules[] = {
+ "&A = AB / B",
+ "&A = A\\u0306/\\u0306",
+ "&c = ch / h"
+ };
+ const static UChar testdata[][2] = {
+ {0x0041 /* 'A' */, 0x0042 /* 'B' */},
+ {0x0041 /* 'A' */, 0x0306 /* combining breve */},
+ {0x0063 /* 'c' */, 0x0068 /* 'h' */}
+ };
+ const static UChar testdata2[][2] = {
+ {0x0063 /* 'c' */, 0x0067 /* 'g' */},
+ {0x0063 /* 'c' */, 0x0068 /* 'h' */},
+ {0x0063 /* 'c' */, 0x006C /* 'l' */}
+ };
+#if 0
+ /*
+ * These pairs of rule strings are not guaranteed to yield the very same mappings.
+ * In fact, LDML 24 recommends an improved way of creating mappings
+ * which always yields different mappings for such pairs. See
+ * http://www.unicode.org/reports/tr35/tr35-33/tr35-collation.html#Orderings
+ */
+ const static char *testrules3[] = {
+ "&z < xyz &xyzw << B",
+ "&z < xyz &xyz << B / w",
+ "&z < ch &achm << B",
+ "&z < ch &a << B / chm",
+ "&\\ud800\\udc00w << B",
+ "&\\ud800\\udc00 << B / w",
+ "&a\\ud800\\udc00m << B",
+ "&a << B / \\ud800\\udc00m",
+ };
+#endif
+
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *coll;
+ UChar rule[256] = {0};
+ uint32_t rlen = 0;
+ int i;
+
+ for (i = 0; i < UPRV_LENGTHOF(testrules); i ++) {
+ UCollationElements *iter1;
+ int j = 0;
+ log_verbose("Rule %s for testing\n", testrules[i]);
+ rlen = u_unescape(testrules[i], rule, 32);
+ coll = ucol_openRules(rule, rlen, UCOL_ON, UCOL_TERTIARY,NULL, &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "Collator creation failed %s -> %s\n", testrules[i], u_errorName(status));
+ return;
+ }
+ iter1 = ucol_openElements(coll, testdata[i], 2, &status);
+ if (U_FAILURE(status)) {
+ log_err("Collation iterator creation failed\n");
+ return;
+ }
+ while (j < 2) {
+ UCollationElements *iter2 = ucol_openElements(coll,
+ &(testdata[i][j]),
+ 1, &status);
+ int32_t ce;
+ if (U_FAILURE(status)) {
+ log_err("Collation iterator creation failed\n");
+ return;
+ }
+ ce = ucol_next(iter2, &status);
+ while (ce != UCOL_NULLORDER) {
+ if (ucol_next(iter1, &status) != ce) {
+ log_err("Collation elements in contraction split does not match\n");
+ return;
+ }
+ ce = ucol_next(iter2, &status);
+ }
+ j ++;
+ ucol_closeElements(iter2);
+ }
+ if (ucol_next(iter1, &status) != UCOL_NULLORDER) {
+ log_err("Collation elements not exhausted\n");
+ return;
+ }
+ ucol_closeElements(iter1);
+ ucol_close(coll);
+ }
+
+ rlen = u_unescape("& a < b < c < ch < d & c = ch / h", rule, 256);
+ coll = ucol_openRules(rule, rlen, UCOL_ON, UCOL_TERTIARY,NULL, &status);
+ if (ucol_strcoll(coll, testdata2[0], 2, testdata2[1], 2) != UCOL_LESS) {
+ log_err("Expected \\u%04x\\u%04x < \\u%04x\\u%04x\n",
+ testdata2[0][0], testdata2[0][1], testdata2[1][0],
+ testdata2[1][1]);
+ return;
+ }
+ if (ucol_strcoll(coll, testdata2[1], 2, testdata2[2], 2) != UCOL_LESS) {
+ log_err("Expected \\u%04x\\u%04x < \\u%04x\\u%04x\n",
+ testdata2[1][0], testdata2[1][1], testdata2[2][0],
+ testdata2[2][1]);
+ return;
+ }
+ ucol_close(coll);
+#if 0 /* see above */
+ for (i = 0; i < UPRV_LENGTHOF(testrules3); i += 2) {
+ log_verbose("testrules3 i==%d \"%s\" vs. \"%s\"\n", i, testrules3[i], testrules3[i + 1]);
+ UCollator *coll1,
+ *coll2;
+ UCollationElements *iter1,
+ *iter2;
+ UChar ch = 0x0042 /* 'B' */;
+ uint32_t ce;
+ rlen = u_unescape(testrules3[i], rule, 32);
+ coll1 = ucol_openRules(rule, rlen, UCOL_ON, UCOL_TERTIARY,NULL, &status);
+ rlen = u_unescape(testrules3[i + 1], rule, 32);
+ coll2 = ucol_openRules(rule, rlen, UCOL_ON, UCOL_TERTIARY,NULL, &status);
+ if (U_FAILURE(status)) {
+ log_err("Collator creation failed %s\n", testrules[i]);
+ return;
+ }
+ iter1 = ucol_openElements(coll1, &ch, 1, &status);
+ iter2 = ucol_openElements(coll2, &ch, 1, &status);
+ if (U_FAILURE(status)) {
+ log_err("Collation iterator creation failed\n");
+ return;
+ }
+ ce = ucol_next(iter1, &status);
+ if (U_FAILURE(status)) {
+ log_err("Retrieving ces failed\n");
+ return;
+ }
+ while (ce != UCOL_NULLORDER) {
+ uint32_t ce2 = (uint32_t)ucol_next(iter2, &status);
+ if (ce == ce2) {
+ log_verbose("CEs match: %08x\n", ce);
+ } else {
+ log_err("CEs do not match: %08x vs. %08x\n", ce, ce2);
+ return;
+ }
+ ce = ucol_next(iter1, &status);
+ if (U_FAILURE(status)) {
+ log_err("Retrieving ces failed\n");
+ return;
+ }
+ }
+ if (ucol_next(iter2, &status) != UCOL_NULLORDER) {
+ log_err("CEs not exhausted\n");
+ return;
+ }
+ ucol_closeElements(iter1);
+ ucol_closeElements(iter2);
+ ucol_close(coll1);
+ ucol_close(coll2);
+ }
+#endif
+}
+
+static void TestExpansion(void) {
+ const static char *testrules[] = {
+#if 0
+ /*
+ * This seems to have tested that M was not mapped to an expansion.
+ * I believe the old builder just did that because it computed the extension CEs
+ * at the very end, which was a bug.
+ * Among other problems, it violated the core tailoring principle
+ * by making an earlier rule depend on a later one.
+ * And, of course, if M did not get an expansion, then it was primary different from K,
+ * unlike what the rule &K<<M says.
+ */
+ "&J << K / B & K << M",
+#endif
+ "&J << K / B << M"
+ };
+ const static UChar testdata[][3] = {
+ {0x004A /*'J'*/, 0x0041 /*'A'*/, 0},
+ {0x004D /*'M'*/, 0x0041 /*'A'*/, 0},
+ {0x004B /*'K'*/, 0x0041 /*'A'*/, 0},
+ {0x004B /*'K'*/, 0x0043 /*'C'*/, 0},
+ {0x004A /*'J'*/, 0x0043 /*'C'*/, 0},
+ {0x004D /*'M'*/, 0x0043 /*'C'*/, 0}
+ };
+
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *coll;
+ UChar rule[256] = {0};
+ uint32_t rlen = 0;
+ int i;
+
+ for (i = 0; i < UPRV_LENGTHOF(testrules); i ++) {
+ int j = 0;
+ log_verbose("Rule %s for testing\n", testrules[i]);
+ rlen = u_unescape(testrules[i], rule, 32);
+ coll = ucol_openRules(rule, rlen, UCOL_ON, UCOL_TERTIARY,NULL, &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "Collator creation failed %s -> %s\n", testrules[i], u_errorName(status));
+ return;
+ }
+
+ for (j = 0; j < 5; j ++) {
+ doTest(coll, testdata[j], testdata[j + 1], UCOL_LESS);
+ }
+ ucol_close(coll);
+ }
+}
+
+#if 0
+/* this test tests the current limitations of the engine */
+/* it always fail, so it is disabled by default */
+static void TestLimitations(void) {
+ /* recursive expansions */
+ {
+ static const char *rule = "&a=b/c&d=c/e";
+ static const char *tlimit01[] = {"add","b","adf"};
+ static const char *tlimit02[] = {"aa","b","af"};
+ log_verbose("recursive expansions\n");
+ genericRulesStarter(rule, tlimit01, UPRV_LENGTHOF(tlimit01));
+ genericRulesStarter(rule, tlimit02, UPRV_LENGTHOF(tlimit02));
+ }
+ /* contractions spanning expansions */
+ {
+ static const char *rule = "&a<<<c/e&g<<<eh";
+ static const char *tlimit01[] = {"ad","c","af","f","ch","h"};
+ static const char *tlimit02[] = {"ad","c","ch","af","f","h"};
+ log_verbose("contractions spanning expansions\n");
+ genericRulesStarter(rule, tlimit01, UPRV_LENGTHOF(tlimit01));
+ genericRulesStarter(rule, tlimit02, UPRV_LENGTHOF(tlimit02));
+ }
+ /* normalization: nulls in contractions */
+ {
+ static const char *rule = "&a<<<\\u0000\\u0302";
+ static const char *tlimit01[] = {"a","\\u0000\\u0302\\u0327"};
+ static const char *tlimit02[] = {"\\u0000\\u0302\\u0327","a"};
+ static const UColAttribute att[] = { UCOL_DECOMPOSITION_MODE };
+ static const UColAttributeValue valOn[] = { UCOL_ON };
+ static const UColAttributeValue valOff[] = { UCOL_OFF };
+
+ log_verbose("NULL in contractions\n");
+ genericRulesStarterWithOptions(rule, tlimit01, 2, att, valOn, 1);
+ genericRulesStarterWithOptions(rule, tlimit02, 2, att, valOn, 1);
+ genericRulesStarterWithOptions(rule, tlimit01, 2, att, valOff, 1);
+ genericRulesStarterWithOptions(rule, tlimit02, 2, att, valOff, 1);
+
+ }
+ /* normalization: contractions spanning normalization */
+ {
+ static const char *rule = "&a<<<\\u0000\\u0302";
+ static const char *tlimit01[] = {"a","\\u0000\\u0302\\u0327"};
+ static const char *tlimit02[] = {"\\u0000\\u0302\\u0327","a"};
+ static const UColAttribute att[] = { UCOL_DECOMPOSITION_MODE };
+ static const UColAttributeValue valOn[] = { UCOL_ON };
+ static const UColAttributeValue valOff[] = { UCOL_OFF };
+
+ log_verbose("contractions spanning normalization\n");
+ genericRulesStarterWithOptions(rule, tlimit01, 2, att, valOn, 1);
+ genericRulesStarterWithOptions(rule, tlimit02, 2, att, valOn, 1);
+ genericRulesStarterWithOptions(rule, tlimit01, 2, att, valOff, 1);
+ genericRulesStarterWithOptions(rule, tlimit02, 2, att, valOff, 1);
+
+ }
+ /* variable top: */
+ {
+ /*static const char *rule2 = "&\\u2010<x=[variable top]<z";*/
+ static const char *rule = "&\\u2010<x<[variable top]=z";
+ /*static const char *rule3 = "&' '<x<[variable top]=z";*/
+ static const char *tlimit01[] = {" ", "z", "zb", "a", " b", "xb", "b", "c" };
+ static const char *tlimit02[] = {"-", "-x", "x","xb", "-z", "z", "zb", "-a", "a", "-b", "b", "c"};
+ static const char *tlimit03[] = {" ", "xb", "z", "zb", "a", " b", "b", "c" };
+ static const UColAttribute att[] = { UCOL_ALTERNATE_HANDLING, UCOL_STRENGTH };
+ static const UColAttributeValue valOn[] = { UCOL_SHIFTED, UCOL_QUATERNARY };
+ static const UColAttributeValue valOff[] = { UCOL_NON_IGNORABLE, UCOL_TERTIARY };
+
+ log_verbose("variable top\n");
+ genericRulesStarterWithOptions(rule, tlimit03, UPRV_LENGTHOF(tlimit03), att, valOn, UPRV_LENGTHOF(att));
+ genericRulesStarterWithOptions(rule, tlimit01, UPRV_LENGTHOF(tlimit01), att, valOn, UPRV_LENGTHOF(att));
+ genericRulesStarterWithOptions(rule, tlimit02, UPRV_LENGTHOF(tlimit02), att, valOn, UPRV_LENGTHOF(att));
+ genericRulesStarterWithOptions(rule, tlimit01, UPRV_LENGTHOF(tlimit01), att, valOff, UPRV_LENGTHOF(att));
+ genericRulesStarterWithOptions(rule, tlimit02, UPRV_LENGTHOF(tlimit02), att, valOff, UPRV_LENGTHOF(att));
+
+ }
+ /* case level */
+ {
+ static const char *rule = "&c<ch<<<cH<<<Ch<<<CH";
+ static const char *tlimit01[] = {"c","CH","Ch","cH","ch"};
+ static const char *tlimit02[] = {"c","CH","cH","Ch","ch"};
+ static const UColAttribute att[] = { UCOL_CASE_FIRST};
+ static const UColAttributeValue valOn[] = { UCOL_UPPER_FIRST};
+ /*static const UColAttributeValue valOff[] = { UCOL_OFF};*/
+ log_verbose("case level\n");
+ genericRulesStarterWithOptions(rule, tlimit01, UPRV_LENGTHOF(tlimit01), att, valOn, UPRV_LENGTHOF(att));
+ genericRulesStarterWithOptions(rule, tlimit02, UPRV_LENGTHOF(tlimit02), att, valOn, UPRV_LENGTHOF(att));
+ /*genericRulesStarterWithOptions(rule, tlimit01, UPRV_LENGTHOF(tlimit01), att, valOff, UPRV_LENGTHOF(att));*/
+ /*genericRulesStarterWithOptions(rule, tlimit02, UPRV_LENGTHOF(tlimit02), att, valOff, UPRV_LENGTHOF(att));*/
+ }
+
+}
+#endif
+
+static void TestBocsuCoverage(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ const char *testString = "\\u0041\\u0441\\u4441\\U00044441\\u4441\\u0441\\u0041";
+ UChar test[256] = {0};
+ uint32_t tlen = u_unescape(testString, test, 32);
+ uint8_t key[256] = {0};
+ uint32_t klen = 0;
+
+ UCollator *coll = ucol_open("", &status);
+ if(U_SUCCESS(status)) {
+ ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_IDENTICAL, &status);
+
+ klen = ucol_getSortKey(coll, test, tlen, key, 256);
+ (void)klen; /* Suppress set but not used warning. */
+
+ ucol_close(coll);
+ } else {
+ log_data_err("Couldn't open UCA\n");
+ }
+}
+
+static void TestVariableTopSetting(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ uint32_t varTopOriginal = 0, varTop1, varTop2;
+ UCollator *coll = ucol_open("", &status);
+ if(U_SUCCESS(status)) {
+
+ static const UChar nul = 0;
+ static const UChar space = 0x20;
+ static const UChar dot = 0x2e; /* punctuation */
+ static const UChar degree = 0xb0; /* symbol */
+ static const UChar dollar = 0x24; /* currency symbol */
+ static const UChar zero = 0x30; /* digit */
+
+ varTopOriginal = ucol_getVariableTop(coll, &status);
+ log_verbose("ucol_getVariableTop(root) -> %08x\n", varTopOriginal);
+ ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
+
+ varTop1 = ucol_setVariableTop(coll, &space, 1, &status);
+ varTop2 = ucol_getVariableTop(coll, &status);
+ log_verbose("ucol_setVariableTop(space) -> %08x\n", varTop1);
+ if(U_FAILURE(status) || varTop1 != varTop2 ||
+ !ucol_equal(coll, &nul, 0, &space, 1) ||
+ ucol_equal(coll, &nul, 0, &dot, 1) ||
+ ucol_equal(coll, &nul, 0, °ree, 1) ||
+ ucol_equal(coll, &nul, 0, &dollar, 1) ||
+ ucol_equal(coll, &nul, 0, &zero, 1) ||
+ ucol_greaterOrEqual(coll, &space, 1, &dot, 1)) {
+ log_err("ucol_setVariableTop(space) did not work - %s\n", u_errorName(status));
+ }
+
+ varTop1 = ucol_setVariableTop(coll, &dot, 1, &status);
+ varTop2 = ucol_getVariableTop(coll, &status);
+ log_verbose("ucol_setVariableTop(dot) -> %08x\n", varTop1);
+ if(U_FAILURE(status) || varTop1 != varTop2 ||
+ !ucol_equal(coll, &nul, 0, &space, 1) ||
+ !ucol_equal(coll, &nul, 0, &dot, 1) ||
+ ucol_equal(coll, &nul, 0, °ree, 1) ||
+ ucol_equal(coll, &nul, 0, &dollar, 1) ||
+ ucol_equal(coll, &nul, 0, &zero, 1) ||
+ ucol_greaterOrEqual(coll, &dot, 1, °ree, 1)) {
+ log_err("ucol_setVariableTop(dot) did not work - %s\n", u_errorName(status));
+ }
+
+ varTop1 = ucol_setVariableTop(coll, °ree, 1, &status);
+ varTop2 = ucol_getVariableTop(coll, &status);
+ log_verbose("ucol_setVariableTop(degree) -> %08x\n", varTop1);
+ if(U_FAILURE(status) || varTop1 != varTop2 ||
+ !ucol_equal(coll, &nul, 0, &space, 1) ||
+ !ucol_equal(coll, &nul, 0, &dot, 1) ||
+ !ucol_equal(coll, &nul, 0, °ree, 1) ||
+ ucol_equal(coll, &nul, 0, &dollar, 1) ||
+ ucol_equal(coll, &nul, 0, &zero, 1) ||
+ ucol_greaterOrEqual(coll, °ree, 1, &dollar, 1)) {
+ log_err("ucol_setVariableTop(degree) did not work - %s\n", u_errorName(status));
+ }
+
+ varTop1 = ucol_setVariableTop(coll, &dollar, 1, &status);
+ varTop2 = ucol_getVariableTop(coll, &status);
+ log_verbose("ucol_setVariableTop(dollar) -> %08x\n", varTop1);
+ if(U_FAILURE(status) || varTop1 != varTop2 ||
+ !ucol_equal(coll, &nul, 0, &space, 1) ||
+ !ucol_equal(coll, &nul, 0, &dot, 1) ||
+ !ucol_equal(coll, &nul, 0, °ree, 1) ||
+ !ucol_equal(coll, &nul, 0, &dollar, 1) ||
+ ucol_equal(coll, &nul, 0, &zero, 1) ||
+ ucol_greaterOrEqual(coll, &dollar, 1, &zero, 1)) {
+ log_err("ucol_setVariableTop(dollar) did not work - %s\n", u_errorName(status));
+ }
+
+ log_verbose("Testing setting variable top to contractions\n");
+ {
+ UChar first[4] = { 0 };
+ first[0] = 0x0040;
+ first[1] = 0x0050;
+ first[2] = 0x0000;
+
+ status = U_ZERO_ERROR;
+ ucol_setVariableTop(coll, first, -1, &status);
+
+ if(U_SUCCESS(status)) {
+ log_err("Invalid contraction succeded in setting variable top!\n");
+ }
+
+ }
+
+ log_verbose("Test restoring variable top\n");
+
+ status = U_ZERO_ERROR;
+ ucol_restoreVariableTop(coll, varTopOriginal, &status);
+ if(varTopOriginal != ucol_getVariableTop(coll, &status)) {
+ log_err("Couldn't restore old variable top\n");
+ }
+
+ log_verbose("Testing calling with error set\n");
+
+ status = U_INTERNAL_PROGRAM_ERROR;
+ varTop1 = ucol_setVariableTop(coll, &space, 1, &status);
+ varTop2 = ucol_getVariableTop(coll, &status);
+ ucol_restoreVariableTop(coll, varTop2, &status);
+ varTop1 = ucol_setVariableTop(NULL, &dot, 1, &status);
+ varTop2 = ucol_getVariableTop(NULL, &status);
+ ucol_restoreVariableTop(NULL, varTop2, &status);
+ if(status != U_INTERNAL_PROGRAM_ERROR) {
+ log_err("Bad reaction to passed error!\n");
+ }
+ ucol_close(coll);
+ } else {
+ log_data_err("Couldn't open UCA collator\n");
+ }
+}
+
+static void TestMaxVariable(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ UColReorderCode oldMax, max;
+ UCollator *coll;
+
+ static const UChar nul = 0;
+ static const UChar space = 0x20;
+ static const UChar dot = 0x2e; /* punctuation */
+ static const UChar degree = 0xb0; /* symbol */
+ static const UChar dollar = 0x24; /* currency symbol */
+ static const UChar zero = 0x30; /* digit */
+
+ coll = ucol_open("", &status);
+ if(U_FAILURE(status)) {
+ log_data_err("Couldn't open root collator\n");
return;
}
- ruleLen = ucol_getRulesEx(coll, UCOL_FULL_RULES, rules, 256);
- log_verbose("TestUCARules\n");
- if(ruleLen > 256) {
- rules = (UChar *)malloc((ruleLen+1)*sizeof(UChar));
- ruleLen = ucol_getRulesEx(coll, UCOL_FULL_RULES, rules, ruleLen);
+ oldMax = ucol_getMaxVariable(coll);
+ log_verbose("ucol_getMaxVariable(root) -> %04x\n", oldMax);
+ ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
+
+ ucol_setMaxVariable(coll, UCOL_REORDER_CODE_SPACE, &status);
+ max = ucol_getMaxVariable(coll);
+ log_verbose("ucol_setMaxVariable(space) -> %04x\n", max);
+ if(U_FAILURE(status) || max != UCOL_REORDER_CODE_SPACE ||
+ !ucol_equal(coll, &nul, 0, &space, 1) ||
+ ucol_equal(coll, &nul, 0, &dot, 1) ||
+ ucol_equal(coll, &nul, 0, °ree, 1) ||
+ ucol_equal(coll, &nul, 0, &dollar, 1) ||
+ ucol_equal(coll, &nul, 0, &zero, 1) ||
+ ucol_greaterOrEqual(coll, &space, 1, &dot, 1)) {
+ log_err("ucol_setMaxVariable(space) did not work - %s\n", u_errorName(status));
}
- log_verbose("Rules length is %d\n", ruleLen);
- UCAfromRules = ucol_openRules(rules, ruleLen, UCOL_OFF, UCOL_TERTIARY, NULL,&status);
+
+ ucol_setMaxVariable(coll, UCOL_REORDER_CODE_PUNCTUATION, &status);
+ max = ucol_getMaxVariable(coll);
+ log_verbose("ucol_setMaxVariable(punctuation) -> %04x\n", max);
+ if(U_FAILURE(status) || max != UCOL_REORDER_CODE_PUNCTUATION ||
+ !ucol_equal(coll, &nul, 0, &space, 1) ||
+ !ucol_equal(coll, &nul, 0, &dot, 1) ||
+ ucol_equal(coll, &nul, 0, °ree, 1) ||
+ ucol_equal(coll, &nul, 0, &dollar, 1) ||
+ ucol_equal(coll, &nul, 0, &zero, 1) ||
+ ucol_greaterOrEqual(coll, &dot, 1, °ree, 1)) {
+ log_err("ucol_setMaxVariable(punctuation) did not work - %s\n", u_errorName(status));
+ }
+
+ ucol_setMaxVariable(coll, UCOL_REORDER_CODE_SYMBOL, &status);
+ max = ucol_getMaxVariable(coll);
+ log_verbose("ucol_setMaxVariable(symbol) -> %04x\n", max);
+ if(U_FAILURE(status) || max != UCOL_REORDER_CODE_SYMBOL ||
+ !ucol_equal(coll, &nul, 0, &space, 1) ||
+ !ucol_equal(coll, &nul, 0, &dot, 1) ||
+ !ucol_equal(coll, &nul, 0, °ree, 1) ||
+ ucol_equal(coll, &nul, 0, &dollar, 1) ||
+ ucol_equal(coll, &nul, 0, &zero, 1) ||
+ ucol_greaterOrEqual(coll, °ree, 1, &dollar, 1)) {
+ log_err("ucol_setMaxVariable(symbol) did not work - %s\n", u_errorName(status));
+ }
+
+ ucol_setMaxVariable(coll, UCOL_REORDER_CODE_CURRENCY, &status);
+ max = ucol_getMaxVariable(coll);
+ log_verbose("ucol_setMaxVariable(currency) -> %04x\n", max);
+ if(U_FAILURE(status) || max != UCOL_REORDER_CODE_CURRENCY ||
+ !ucol_equal(coll, &nul, 0, &space, 1) ||
+ !ucol_equal(coll, &nul, 0, &dot, 1) ||
+ !ucol_equal(coll, &nul, 0, °ree, 1) ||
+ !ucol_equal(coll, &nul, 0, &dollar, 1) ||
+ ucol_equal(coll, &nul, 0, &zero, 1) ||
+ ucol_greaterOrEqual(coll, &dollar, 1, &zero, 1)) {
+ log_err("ucol_setMaxVariable(currency) did not work - %s\n", u_errorName(status));
+ }
+
+ log_verbose("Test restoring maxVariable\n");
+ status = U_ZERO_ERROR;
+ ucol_setMaxVariable(coll, oldMax, &status);
+ if(oldMax != ucol_getMaxVariable(coll)) {
+ log_err("Couldn't restore old maxVariable\n");
+ }
+
+ log_verbose("Testing calling with error set\n");
+ status = U_INTERNAL_PROGRAM_ERROR;
+ ucol_setMaxVariable(coll, UCOL_REORDER_CODE_SPACE, &status);
+ max = ucol_getMaxVariable(coll);
+ if(max != oldMax || status != U_INTERNAL_PROGRAM_ERROR) {
+ log_err("Bad reaction to passed error!\n");
+ }
+ ucol_close(coll);
+}
+
+static void TestNonChars(void) {
+ static const char *test[] = {
+ "\\u0000", /* ignorable */
+ "\\uFFFE", /* special merge-sort character with minimum non-ignorable weights */
+ "\\uFDD0", "\\uFDEF",
+ "\\U0001FFFE", "\\U0001FFFF", /* UCA 6.0: noncharacters are treated like unassigned, */
+ "\\U0002FFFE", "\\U0002FFFF", /* not like ignorable. */
+ "\\U0003FFFE", "\\U0003FFFF",
+ "\\U0004FFFE", "\\U0004FFFF",
+ "\\U0005FFFE", "\\U0005FFFF",
+ "\\U0006FFFE", "\\U0006FFFF",
+ "\\U0007FFFE", "\\U0007FFFF",
+ "\\U0008FFFE", "\\U0008FFFF",
+ "\\U0009FFFE", "\\U0009FFFF",
+ "\\U000AFFFE", "\\U000AFFFF",
+ "\\U000BFFFE", "\\U000BFFFF",
+ "\\U000CFFFE", "\\U000CFFFF",
+ "\\U000DFFFE", "\\U000DFFFF",
+ "\\U000EFFFE", "\\U000EFFFF",
+ "\\U000FFFFE", "\\U000FFFFF",
+ "\\U0010FFFE", "\\U0010FFFF",
+ "\\uFFFF" /* special character with maximum primary weight */
+ };
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *coll = ucol_open("en_US", &status);
+
+ log_verbose("Test non characters\n");
+
if(U_SUCCESS(status)) {
- ucol_close(UCAfromRules);
+ genericOrderingTestWithResult(coll, test, 35, UCOL_LESS);
} else {
- log_verbose("Unable to create a collator from UCARules!\n");
+ log_err_status(status, "Unable to open collator\n");
}
-/*
- u_unescape(blah, b, 256);
- ucol_getSortKey(coll, b, 1, res, 256);
-*/
+
ucol_close(coll);
- if(rules != b) {
- free(rules);
- }
}
+static void TestExtremeCompression(void) {
+ static char *test[4];
+ int32_t j = 0, i = 0;
+
+ for(i = 0; i<4; i++) {
+ test[i] = (char *)malloc(2048*sizeof(char));
+ }
-/* Pinyin tonal order */
-/*
- A < .. (\u0101) < .. (\u00e1) < .. (\u01ce) < .. (\u00e0)
- (w/macron)< (w/acute)< (w/caron)< (w/grave)
- E < .. (\u0113) < .. (\u00e9) < .. (\u011b) < .. (\u00e8)
- I < .. (\u012b) < .. (\u00ed) < .. (\u01d0) < .. (\u00ec)
- O < .. (\u014d) < .. (\u00f3) < .. (\u01d2) < .. (\u00f2)
- U < .. (\u016b) < .. (\u00fa) < .. (\u01d4) < .. (\u00f9)
- < .. (\u01d6) < .. (\u01d8) < .. (\u01da) < .. (\u01dc) <
-.. (\u00fc)
+ for(j = 20; j < 500; j++) {
+ for(i = 0; i<4; i++) {
+ uprv_memset(test[i], 'a', (j-1)*sizeof(char));
+ test[i][j-1] = (char)('a'+i);
+ test[i][j] = 0;
+ }
+ genericLocaleStarter("en_US", (const char **)test, 4);
+ }
-However, in testing we got the following order:
- A < .. (\u00e1) < .. (\u00e0) < .. (\u01ce) < .. (\u0101)
- (w/acute)< (w/grave)< (w/caron)< (w/macron)
- E < .. (\u00e9) < .. (\u00e8) < .. (\u00ea) < .. (\u011b) <
-.. (\u0113)
- I < .. (\u00ed) < .. (\u00ec) < .. (\u01d0) < .. (\u012b)
- O < .. (\u00f3) < .. (\u00f2) < .. (\u01d2) < .. (\u014d)
- U < .. (\u00fa) < .. (\u00f9) < .. (\u01d4) < .. (\u00fc) <
-.. (\u01d8)
- < .. (\u01dc) < .. (\u01da) < .. (\u01d6) < .. (\u016b)
-*/
-static void TestBefore(void) {
- const static char *data[] = {
- "\\u0101", "\\u00e1", "\\u01ce", "\\u00e0", "A",
- "\\u0113", "\\u00e9", "\\u011b", "\\u00e8", "E",
- "\\u012b", "\\u00ed", "\\u01d0", "\\u00ec", "I",
- "\\u014d", "\\u00f3", "\\u01d2", "\\u00f2", "O",
- "\\u016b", "\\u00fa", "\\u01d4", "\\u00f9", "U",
- "\\u01d6", "\\u01d8", "\\u01da", "\\u01dc", "\\u00fc"
- };
- genericRulesStarter(
- "&[before 1]a<\\u0101<\\u00e1<\\u01ce<\\u00e0"
- "&[before 1]e<\\u0113<\\u00e9<\\u011b<\\u00e8"
- "&[before 1]i<\\u012b<\\u00ed<\\u01d0<\\u00ec"
- "&[before 1]o<\\u014d<\\u00f3<\\u01d2<\\u00f2"
- "&[before 1]u<\\u016b<\\u00fa<\\u01d4<\\u00f9"
- "&u<\\u01d6<\\u01d8<\\u01da<\\u01dc<\\u00fc",
- data, sizeof(data)/sizeof(data[0]));
+ for(i = 0; i<4; i++) {
+ free(test[i]);
+ }
}
#if 0
-/* superceded by TestBeforePinyin */
-static void TestJ784(void) {
- const static char *data[] = {
- "A", "\\u0101", "\\u00e1", "\\u01ce", "\\u00e0",
- "E", "\\u0113", "\\u00e9", "\\u011b", "\\u00e8",
- "I", "\\u012b", "\\u00ed", "\\u01d0", "\\u00ec",
- "O", "\\u014d", "\\u00f3", "\\u01d2", "\\u00f2",
- "U", "\\u016b", "\\u00fa", "\\u01d4", "\\u00f9",
- "\\u00fc",
- "\\u01d6", "\\u01d8", "\\u01da", "\\u01dc"
+static void TestExtremeCompression(void) {
+ static char *test[4];
+ int32_t j = 0, i = 0;
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *coll = ucol_open("en_US", status);
+ for(i = 0; i<4; i++) {
+ test[i] = (char *)malloc(2048*sizeof(char));
+ }
+ for(j = 10; j < 2048; j++) {
+ for(i = 0; i<4; i++) {
+ uprv_memset(test[i], 'a', (j-2)*sizeof(char));
+ test[i][j-1] = (char)('a'+i);
+ test[i][j] = 0;
+ }
+ }
+ genericLocaleStarter("en_US", (const char **)test, 4);
+
+ for(j = 10; j < 2048; j++) {
+ for(i = 0; i<1; i++) {
+ uprv_memset(test[i], 'a', (j-1)*sizeof(char));
+ test[i][j] = 0;
+ }
+ }
+ for(i = 0; i<4; i++) {
+ free(test[i]);
+ }
+}
+#endif
+
+static void TestSurrogates(void) {
+ static const char *test[] = {
+ "z","\\ud900\\udc25", "\\ud805\\udc50",
+ "\\ud800\\udc00y", "\\ud800\\udc00r",
+ "\\ud800\\udc00f", "\\ud800\\udc00",
+ "\\ud800\\udc00c", "\\ud800\\udc00b",
+ "\\ud800\\udc00fa", "\\ud800\\udc00fb",
+ "\\ud800\\udc00a",
+ "c", "b"
+ };
+
+ static const char *rule =
+ "&z < \\ud900\\udc25 < \\ud805\\udc50"
+ "< \\ud800\\udc00y < \\ud800\\udc00r"
+ "< \\ud800\\udc00f << \\ud800\\udc00"
+ "< \\ud800\\udc00fa << \\ud800\\udc00fb"
+ "< \\ud800\\udc00a < c < b" ;
+
+ genericRulesStarter(rule, test, 14);
+}
+
+/* This is a test for prefix implementation, used by JIS X 4061 collation rules */
+static void TestPrefix(void) {
+ uint32_t i;
+
+ static const struct {
+ const char *rules;
+ const char *data[50];
+ const uint32_t len;
+ } tests[] = {
+ { "&z <<< z|a",
+ {"zz", "za"}, 2 },
+
+ { "&z <<< z| a",
+ {"zz", "za"}, 2 },
+ { "[strength I]"
+ "&a=\\ud900\\udc25"
+ "&z<<<\\ud900\\udc25|a",
+ {"aa", "az", "\\ud900\\udc25z", "\\ud900\\udc25a", "zz"}, 4 },
};
- genericLocaleStarter("zh", data, sizeof(data)/sizeof(data[0]));
+
+
+ for(i = 0; i<UPRV_LENGTHOF(tests); i++) {
+ genericRulesStarter(tests[i].rules, tests[i].data, tests[i].len);
+ }
}
-#endif
-#if 0
-/* superceded by the changes to the lv locale */
-static void TestJ831(void) {
- const static char *data[] = {
- "I",
- "i",
- "Y",
- "y"
+/* This test uses data suplied by Masashiko Maedera to test the implementation */
+/* JIS X 4061 collation order implementation */
+static void TestNewJapanese(void) {
+
+ static const char * const test1[] = {
+ "\\u30b7\\u30e3\\u30fc\\u30ec",
+ "\\u30b7\\u30e3\\u30a4",
+ "\\u30b7\\u30e4\\u30a3",
+ "\\u30b7\\u30e3\\u30ec",
+ "\\u3061\\u3087\\u3053",
+ "\\u3061\\u3088\\u3053",
+ "\\u30c1\\u30e7\\u30b3\\u30ec\\u30fc\\u30c8",
+ "\\u3066\\u30fc\\u305f",
+ "\\u30c6\\u30fc\\u30bf",
+ "\\u30c6\\u30a7\\u30bf",
+ "\\u3066\\u3048\\u305f",
+ "\\u3067\\u30fc\\u305f",
+ "\\u30c7\\u30fc\\u30bf",
+ "\\u30c7\\u30a7\\u30bf",
+ "\\u3067\\u3048\\u305f",
+ "\\u3066\\u30fc\\u305f\\u30fc",
+ "\\u30c6\\u30fc\\u30bf\\u30a1",
+ "\\u30c6\\u30a7\\u30bf\\u30fc",
+ "\\u3066\\u3047\\u305f\\u3041",
+ "\\u3066\\u3048\\u305f\\u30fc",
+ "\\u3067\\u30fc\\u305f\\u30fc",
+ "\\u30c7\\u30fc\\u30bf\\u30a1",
+ "\\u3067\\u30a7\\u305f\\u30a1",
+ "\\u30c7\\u3047\\u30bf\\u3041",
+ "\\u30c7\\u30a8\\u30bf\\u30a2",
+ "\\u3072\\u3086",
+ "\\u3073\\u3085\\u3042",
+ "\\u3074\\u3085\\u3042",
+ "\\u3073\\u3085\\u3042\\u30fc",
+ "\\u30d3\\u30e5\\u30a2\\u30fc",
+ "\\u3074\\u3085\\u3042\\u30fc",
+ "\\u30d4\\u30e5\\u30a2\\u30fc",
+ "\\u30d2\\u30e5\\u30a6",
+ "\\u30d2\\u30e6\\u30a6",
+ "\\u30d4\\u30e5\\u30a6\\u30a2",
+ "\\u3073\\u3085\\u30fc\\u3042\\u30fc",
+ "\\u30d3\\u30e5\\u30fc\\u30a2\\u30fc",
+ "\\u30d3\\u30e5\\u30a6\\u30a2\\u30fc",
+ "\\u3072\\u3085\\u3093",
+ "\\u3074\\u3085\\u3093",
+ "\\u3075\\u30fc\\u308a",
+ "\\u30d5\\u30fc\\u30ea",
+ "\\u3075\\u3045\\u308a",
+ "\\u3075\\u30a5\\u308a",
+ "\\u3075\\u30a5\\u30ea",
+ "\\u30d5\\u30a6\\u30ea",
+ "\\u3076\\u30fc\\u308a",
+ "\\u30d6\\u30fc\\u30ea",
+ "\\u3076\\u3045\\u308a",
+ "\\u30d6\\u30a5\\u308a",
+ "\\u3077\\u3046\\u308a",
+ "\\u30d7\\u30a6\\u30ea",
+ "\\u3075\\u30fc\\u308a\\u30fc",
+ "\\u30d5\\u30a5\\u30ea\\u30fc",
+ "\\u3075\\u30a5\\u308a\\u30a3",
+ "\\u30d5\\u3045\\u308a\\u3043",
+ "\\u30d5\\u30a6\\u30ea\\u30fc",
+ "\\u3075\\u3046\\u308a\\u3043",
+ "\\u30d6\\u30a6\\u30ea\\u30a4",
+ "\\u3077\\u30fc\\u308a\\u30fc",
+ "\\u3077\\u30a5\\u308a\\u30a4",
+ "\\u3077\\u3046\\u308a\\u30fc",
+ "\\u30d7\\u30a6\\u30ea\\u30a4",
+ "\\u30d5\\u30fd",
+ "\\u3075\\u309e",
+ "\\u3076\\u309d",
+ "\\u3076\\u3075",
+ "\\u3076\\u30d5",
+ "\\u30d6\\u3075",
+ "\\u30d6\\u30d5",
+ "\\u3076\\u309e",
+ "\\u3076\\u3077",
+ "\\u30d6\\u3077",
+ "\\u3077\\u309d",
+ "\\u30d7\\u30fd",
+ "\\u3077\\u3075",
+};
+
+ static const char *test2[] = {
+ "\\u306f\\u309d", /* H\\u309d */
+ "\\u30cf\\u30fd", /* K\\u30fd */
+ "\\u306f\\u306f", /* HH */
+ "\\u306f\\u30cf", /* HK */
+ "\\u30cf\\u30cf", /* KK */
+ "\\u306f\\u309e", /* H\\u309e */
+ "\\u30cf\\u30fe", /* K\\u30fe */
+ "\\u306f\\u3070", /* HH\\u309b */
+ "\\u30cf\\u30d0", /* KK\\u309b */
+ "\\u306f\\u3071", /* HH\\u309c */
+ "\\u30cf\\u3071", /* KH\\u309c */
+ "\\u30cf\\u30d1", /* KK\\u309c */
+ "\\u3070\\u309d", /* H\\u309b\\u309d */
+ "\\u30d0\\u30fd", /* K\\u309b\\u30fd */
+ "\\u3070\\u306f", /* H\\u309bH */
+ "\\u30d0\\u30cf", /* K\\u309bK */
+ "\\u3070\\u309e", /* H\\u309b\\u309e */
+ "\\u30d0\\u30fe", /* K\\u309b\\u30fe */
+ "\\u3070\\u3070", /* H\\u309bH\\u309b */
+ "\\u30d0\\u3070", /* K\\u309bH\\u309b */
+ "\\u30d0\\u30d0", /* K\\u309bK\\u309b */
+ "\\u3070\\u3071", /* H\\u309bH\\u309c */
+ "\\u30d0\\u30d1", /* K\\u309bK\\u309c */
+ "\\u3071\\u309d", /* H\\u309c\\u309d */
+ "\\u30d1\\u30fd", /* K\\u309c\\u30fd */
+ "\\u3071\\u306f", /* H\\u309cH */
+ "\\u30d1\\u30cf", /* K\\u309cK */
+ "\\u3071\\u3070", /* H\\u309cH\\u309b */
+ "\\u3071\\u30d0", /* H\\u309cK\\u309b */
+ "\\u30d1\\u30d0", /* K\\u309cK\\u309b */
+ "\\u3071\\u3071", /* H\\u309cH\\u309c */
+ "\\u30d1\\u30d1", /* K\\u309cK\\u309c */
+ };
+ /*
+ static const char *test3[] = {
+ "\\u221er\\u221e",
+ "\\u221eR#",
+ "\\u221et\\u221e",
+ "#r\\u221e",
+ "#R#",
+ "#t%",
+ "#T%",
+ "8t\\u221e",
+ "8T\\u221e",
+ "8t#",
+ "8T#",
+ "8t%",
+ "8T%",
+ "8t8",
+ "8T8",
+ "\\u03c9r\\u221e",
+ "\\u03a9R%",
+ "rr\\u221e",
+ "rR\\u221e",
+ "Rr\\u221e",
+ "RR\\u221e",
+ "RT%",
+ "rt8",
+ "tr\\u221e",
+ "tr8",
+ "TR8",
+ "tt8",
+ "\\u30b7\\u30e3\\u30fc\\u30ec",
};
- genericLocaleStarter("lv", data, sizeof(data)/sizeof(data[0]));
+ */
+ static const UColAttribute att[] = { UCOL_STRENGTH };
+ static const UColAttributeValue val[] = { UCOL_QUATERNARY };
+
+ static const UColAttribute attShifted[] = { UCOL_STRENGTH, UCOL_ALTERNATE_HANDLING};
+ static const UColAttributeValue valShifted[] = { UCOL_QUATERNARY, UCOL_SHIFTED };
+
+ genericLocaleStarterWithOptions("ja", test1, UPRV_LENGTHOF(test1), att, val, 1);
+ genericLocaleStarterWithOptions("ja", test2, UPRV_LENGTHOF(test2), att, val, 1);
+ /*genericLocaleStarter("ja", test3, UPRV_LENGTHOF(test3));*/
+ genericLocaleStarterWithOptions("ja", test1, UPRV_LENGTHOF(test1), attShifted, valShifted, 2);
+ genericLocaleStarterWithOptions("ja", test2, UPRV_LENGTHOF(test2), attShifted, valShifted, 2);
}
-#endif
-static void TestJ815(void) {
- const static char *data[] = {
- "aa",
- "Aa",
- "ab",
- "Ab",
- "ad",
- "Ad",
- "ae",
- "Ae",
- "\\u00e6",
- "\\u00c6",
- "af",
- "Af",
- "b",
- "B"
+static void TestStrCollIdenticalPrefix(void) {
+ const char* rule = "&\\ud9b0\\udc70=\\ud9b0\\udc71";
+ const char* test[] = {
+ "ab\\ud9b0\\udc70",
+ "ab\\ud9b0\\udc71"
};
- genericLocaleStarter("fr", data, sizeof(data)/sizeof(data[0]));
- genericRulesStarter("[backwards 2]&A<<\\u00e6/e<<<\\u00c6/E", data, sizeof(data)/sizeof(data[0]));
+ genericRulesStarterWithResult(rule, test, UPRV_LENGTHOF(test), UCOL_EQUAL);
}
+/* Contractions should have all their canonically equivalent */
+/* strings included */
+static void TestContractionClosure(void) {
+ static const struct {
+ const char *rules;
+ const char *data[10];
+ const uint32_t len;
+ } tests[] = {
+ { "&b=\\u00e4\\u00e4",
+ { "b", "\\u00e4\\u00e4", "a\\u0308a\\u0308", "\\u00e4a\\u0308", "a\\u0308\\u00e4" }, 5},
+ { "&b=\\u00C5",
+ { "b", "\\u00C5", "A\\u030A", "\\u212B" }, 4},
+ };
+ uint32_t i;
-/*
-"& a < b < c < d& r < c", "& a < b < d& r < c",
-"& a < b < c < d& c < m", "& a < b < c < m < d",
-"& a < b < c < d& a < m", "& a < m < b < c < d",
-"& a <<< b << c < d& a < m", "& a <<< b << c < m < d",
-"& a < b < c < d& [before 1] c < m", "& a < b < m < c < d",
-"& a < b <<< c << d <<< e& [before 3] e <<< x", "& a < b <<< c << d <<< x <<< e",
-"& a < b <<< c << d <<< e& [before 2] e <<< x", "& a < b <<< c <<< x << d <<< e",
-"& a < b <<< c << d <<< e& [before 1] e <<< x", "& a <<< x < b <<< c << d <<< e",
-"& a < b <<< c << d <<< e <<< f < g& [before 1] g < x", "& a < b <<< c << d <<< e <<< f < x < g",
-*/
-static void TestRedundantRules(void) {
- int32_t i;
+ for(i = 0; i<UPRV_LENGTHOF(tests); i++) {
+ genericRulesStarterWithResult(tests[i].rules, tests[i].data, tests[i].len, UCOL_EQUAL);
+ }
+}
- struct {
- const char *rules;
- const char *expectedRules;
- const char *testdata[8];
- uint32_t testdatalen;
+/* This tests also fails*/
+static void TestBeforePrefixFailure(void) {
+ static const struct {
+ const char *rules;
+ const char *data[10];
+ const uint32_t len;
} tests[] = {
- /* this test conflicts with positioning of CODAN placeholder */
- /*{
- "& a <<< b <<< c << d <<< e& [before 1] e <<< x",
- "&\\u2089<<<x",
- {"\\u2089", "x"}, 2
- }, */
- /* this test conflicts with the [before x] syntax tightening */
- /*{
- "& b <<< c <<< d << e <<< f& [before 1] f <<< x",
- "&\\u0252<<<x",
- {"\\u0252", "x"}, 2
- }, */
- /* this test conflicts with the [before x] syntax tightening */
- /*{
- "& a < b <<< c << d <<< e& [before 1] e <<< x",
- "& a <<< x < b <<< c << d <<< e",
- {"a", "x", "b", "c", "d", "e"}, 6
- }, */
- {
- "& a < b < c < d& [before 1] c < m",
- "& a < b < m < c < d",
- {"a", "b", "m", "c", "d"}, 5
- },
- {
- "& a < b <<< c << d <<< e& [before 3] e <<< x",
- "& a < b <<< c << d <<< x <<< e",
- {"a", "b", "c", "d", "x", "e"}, 6
- },
- /* this test conflicts with the [before x] syntax tightening */
- /* {
- "& a < b <<< c << d <<< e& [before 2] e <<< x",
- "& a < b <<< c <<< x << d <<< e",
- {"a", "b", "c", "x", "d", "e"},, 6
- }, */
- {
- "& a < b <<< c << d <<< e <<< f < g& [before 1] g < x",
- "& a < b <<< c << d <<< e <<< f < x < g",
- {"a", "b", "c", "d", "e", "f", "x", "g"}, 8
- },
- {
- "& a <<< b << c < d& a < m",
- "& a <<< b << c < m < d",
- {"a", "b", "c", "m", "d"}, 5
- },
- {
- "&a<b<<b\\u0301 &z<b",
- "&a<b\\u0301 &z<b",
- {"a", "b\\u0301", "z", "b"}, 4
- },
- {
- "&z<m<<<q<<<m",
- "&z<q<<<m",
- {"z", "q", "m"},3
- },
- {
- "&z<<<m<q<<<m",
- "&z<q<<<m",
- {"z", "q", "m"}, 3
- },
- {
- "& a < b < c < d& r < c",
- "& a < b < d& r < c",
- {"a", "b", "d"}, 3
- },
- {
- "& a < b < c < d& r < c",
- "& a < b < d& r < c",
- {"r", "c"}, 2
- },
- {
- "& a < b < c < d& c < m",
- "& a < b < c < m < d",
- {"a", "b", "c", "m", "d"}, 5
- },
- {
- "& a < b < c < d& a < m",
- "& a < m < b < c < d",
- {"a", "m", "b", "c", "d"}, 5
- }
+ { "&g <<< a"
+ "&[before 3]\\uff41 <<< x",
+ {"x", "\\uff41"}, 2 },
+ { "&\\u30A7=\\u30A7=\\u3047=\\uff6a"
+ "&\\u30A8=\\u30A8=\\u3048=\\uff74"
+ "&[before 3]\\u30a7<<<\\u30a9",
+ {"\\u30a9", "\\u30a7"}, 2 },
+ { "&[before 3]\\u30a7<<<\\u30a9"
+ "&\\u30A7=\\u30A7=\\u3047=\\uff6a"
+ "&\\u30A8=\\u30A8=\\u3048=\\uff74",
+ {"\\u30a9", "\\u30a7"}, 2 },
};
+ uint32_t i;
- UCollator *credundant = NULL;
- UCollator *cresulting = NULL;
- UErrorCode status = U_ZERO_ERROR;
- UChar rlz[2048] = { 0 };
- uint32_t rlen = 0;
+ for(i = 0; i<UPRV_LENGTHOF(tests); i++) {
+ genericRulesStarter(tests[i].rules, tests[i].data, tests[i].len);
+ }
+
+#if 0
+ const char* rule1 =
+ "&\\u30A7=\\u30A7=\\u3047=\\uff6a"
+ "&\\u30A8=\\u30A8=\\u3048=\\uff74"
+ "&[before 3]\\u30a7<<<\\u30c6|\\u30fc";
+ const char* rule2 =
+ "&[before 3]\\u30a7<<<\\u30c6|\\u30fc"
+ "&\\u30A7=\\u30A7=\\u3047=\\uff6a"
+ "&\\u30A8=\\u30A8=\\u3048=\\uff74";
+ const char* test[] = {
+ "\\u30c6\\u30fc\\u30bf",
+ "\\u30c6\\u30a7\\u30bf",
+ };
+ genericRulesStarter(rule1, test, UPRV_LENGTHOF(test));
+ genericRulesStarter(rule2, test, UPRV_LENGTHOF(test));
+/* this piece of code should be in some sort of verbose mode */
+/* it gets the collation elements for elements and prints them */
+/* This is useful when trying to see whether the problem is */
+ {
+ UErrorCode status = U_ZERO_ERROR;
+ uint32_t i = 0;
+ UCollationElements *it = NULL;
+ uint32_t CE;
+ UChar string[256];
+ uint32_t uStringLen;
+ UCollator *coll = NULL;
- for(i = 0; i<sizeof(tests)/sizeof(tests[0]); i++) {
- log_verbose("testing rule %s, expected to be %s\n", tests[i].rules, tests[i].expectedRules);
- rlen = u_unescape(tests[i].rules, rlz, 2048);
+ uStringLen = u_unescape(rule1, string, 256);
- credundant = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT, NULL,&status);
- if(status == U_FILE_ACCESS_ERROR) {
- log_data_err("Is your data around?\n");
- return;
- } else if(U_FAILURE(status)) {
- log_err("Error opening collator\n");
- return;
- }
+ coll = ucol_openRules(string, uStringLen, UCOL_DEFAULT, UCOL_DEFAULT, NULL, &status);
- rlen = u_unescape(tests[i].expectedRules, rlz, 2048);
- cresulting = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT, NULL,&status);
+ /*coll = ucol_open("ja_JP_JIS", &status);*/
+ it = ucol_openElements(coll, string, 0, &status);
- testAgainstUCA(cresulting, credundant, "expected", TRUE, &status);
+ for(i = 0; i < UPRV_LENGTHOF(test); i++) {
+ log_verbose("%s\n", test[i]);
+ uStringLen = u_unescape(test[i], string, 256);
+ ucol_setText(it, string, uStringLen, &status);
- ucol_close(credundant);
- ucol_close(cresulting);
+ while((CE=ucol_next(it, &status)) != UCOL_NULLORDER) {
+ log_verbose("%08X\n", CE);
+ }
+ log_verbose("\n");
- log_verbose("testing using data\n");
+ }
- genericRulesStarter(tests[i].rules, tests[i].testdata, tests[i].testdatalen);
+ ucol_closeElements(it);
+ ucol_close(coll);
}
-
+#endif
}
-static void TestExpansionSyntax(void) {
- int32_t i;
-
- const static char *rules[] = {
- "&AE <<< a << b <<< c &d <<< f",
- "&AE <<< a <<< b << c << d < e < f <<< g",
- "&AE <<< B <<< C / D <<< F"
- };
-
- const static char *expectedRules[] = {
- "&A <<< a / E << b / E <<< c /E &d <<< f",
- "&A <<< a / E <<< b / E << c / E << d / E < e < f <<< g",
- "&A <<< B / E <<< C / ED <<< F / E"
- };
-
- const static char *testdata[][8] = {
- {"AE", "a", "b", "c"},
- {"AE", "a", "b", "c", "d", "e", "f", "g"},
- {"AE", "B", "C"} /* / ED <<< F / E"},*/
- };
-
- const static uint32_t testdatalen[] = {
- 4,
- 8,
- 3
+static void TestPrefixCompose(void) {
+ const char* rule1 =
+ "&\\u30a7<<<\\u30ab|\\u30fc=\\u30ac|\\u30fc";
+ /*
+ const char* test[] = {
+ "\\u30c6\\u30fc\\u30bf",
+ "\\u30c6\\u30a7\\u30bf",
};
+ */
+ {
+ UErrorCode status = U_ZERO_ERROR;
+ /*uint32_t i = 0;*/
+ /*UCollationElements *it = NULL;*/
+/* uint32_t CE;*/
+ UChar string[256];
+ uint32_t uStringLen;
+ UCollator *coll = NULL;
+ uStringLen = u_unescape(rule1, string, 256);
+ coll = ucol_openRules(string, uStringLen, UCOL_DEFAULT, UCOL_DEFAULT, NULL, &status);
+ ucol_close(coll);
+ }
- UCollator *credundant = NULL;
- UCollator *cresulting = NULL;
- UErrorCode status = U_ZERO_ERROR;
- UChar rlz[2048] = { 0 };
- uint32_t rlen = 0;
- for(i = 0; i<sizeof(rules)/sizeof(rules[0]); i++) {
- log_verbose("testing rule %s, expected to be %s\n", rules[i], expectedRules[i]);
- rlen = u_unescape(rules[i], rlz, 2048);
+}
- credundant = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT, NULL, &status);
- if(status == U_FILE_ACCESS_ERROR) {
- log_data_err("Is your data around?\n");
- return;
- } else if(U_FAILURE(status)) {
- log_err("Error opening collator\n");
- return;
- }
- rlen = u_unescape(expectedRules[i], rlz, 2048);
- cresulting = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT, NULL,&status);
+/*
+[last variable] last variable value
+[last primary ignorable] largest CE for primary ignorable
+[last secondary ignorable] largest CE for secondary ignorable
+[last tertiary ignorable] largest CE for tertiary ignorable
+[top] guaranteed to be above all implicit CEs, for now and in the future (in 1.8)
+*/
- /* testAgainstUCA still doesn't handle expansions correctly, so this is not run */
- /* as a hard error test, but only in information mode */
- testAgainstUCA(cresulting, credundant, "expected", FALSE, &status);
+static void TestRuleOptions(void) {
+ /* values here are hardcoded and are correct for the current UCA
+ * when the UCA changes, one might be forced to change these
+ * values.
+ */
- ucol_close(credundant);
- ucol_close(cresulting);
+ /*
+ * These strings contain the last character before [variable top]
+ * and the first and second characters (by primary weights) after it.
+ * See FractionalUCA.txt. For example:
+ [last variable [0C FE, 05, 05]] # U+10A7F OLD SOUTH ARABIAN NUMERIC INDICATOR
+ [variable top = 0C FE]
+ [first regular [0D 0A, 05, 05]] # U+0060 GRAVE ACCENT
+ and
+ 00B4; [0D 0C, 05, 05]
+ *
+ * Note: Starting with UCA 6.0, the [variable top] collation element
+ * is not the weight of any character or string,
+ * which means that LAST_VARIABLE_CHAR_STRING sorts before [last variable].
+ */
+#define LAST_VARIABLE_CHAR_STRING "\\U00010A7F"
+#define FIRST_REGULAR_CHAR_STRING "\\u0060"
+#define SECOND_REGULAR_CHAR_STRING "\\u00B4"
- log_verbose("testing using data\n");
+ /*
+ * This string has to match the character that has the [last regular] weight
+ * which changes with each UCA version.
+ * See the bottom of FractionalUCA.txt which says something like
+ [last regular [7A FE, 05, 05]] # U+1342E EGYPTIAN HIEROGLYPH AA032
+ *
+ * Note: Starting with UCA 6.0, the [last regular] collation element
+ * is not the weight of any character or string,
+ * which means that LAST_REGULAR_CHAR_STRING sorts before [last regular].
+ */
+#define LAST_REGULAR_CHAR_STRING "\\U0001342E"
- genericRulesStarter(rules[i], testdata[i], testdatalen[i]);
- }
-}
+ static const struct {
+ const char *rules;
+ const char *data[10];
+ const uint32_t len;
+ } tests[] = {
+#if 0
+ /* "you cannot go before ...": The parser now sets an error for such nonsensical rules. */
+ /* - all befores here amount to zero */
+ { "&[before 3][first tertiary ignorable]<<<a",
+ { "\\u0000", "a"}, 2
+ }, /* you cannot go before first tertiary ignorable */
-static void TestCase(void)
-{
- const static UChar gRules[MAX_TOKEN_LEN] =
- /*" & 0 < 1,\u2461<a,A"*/
- { 0x0026, 0x0030, 0x003C, 0x0031, 0x002C, 0x2460, 0x003C, 0x0061, 0x002C, 0x0041, 0x0000 };
+ { "&[before 3][last tertiary ignorable]<<<a",
+ { "\\u0000", "a"}, 2
+ }, /* you cannot go before last tertiary ignorable */
+#endif
+ /*
+ * However, there is a real secondary ignorable (artificial addition in FractionalUCA.txt),
+ * and it *is* possible to "go before" that.
+ */
+ { "&[before 3][first secondary ignorable]<<<a",
+ { "\\u0000", "a"}, 2
+ },
- const static UChar testCase[][MAX_TOKEN_LEN] =
- {
- /*0*/ {0x0031 /*'1'*/, 0x0061/*'a'*/, 0x0000},
- /*1*/ {0x0031 /*'1'*/, 0x0041/*'A'*/, 0x0000},
- /*2*/ {0x2460 /*circ'1'*/, 0x0061/*'a'*/, 0x0000},
- /*3*/ {0x2460 /*circ'1'*/, 0x0041/*'A'*/, 0x0000}
- };
+ { "&[before 3][last secondary ignorable]<<<a",
+ { "\\u0000", "a"}, 2
+ },
- const static UCollationResult caseTestResults[][9] =
- {
- { UCOL_LESS, UCOL_LESS, UCOL_LESS, 0, UCOL_LESS, UCOL_LESS, 0, 0, UCOL_LESS },
- { UCOL_GREATER, UCOL_LESS, UCOL_LESS, 0, UCOL_LESS, UCOL_LESS, 0, 0, UCOL_GREATER },
- { UCOL_LESS, UCOL_LESS, UCOL_LESS, 0, UCOL_GREATER, UCOL_LESS, 0, 0, UCOL_LESS },
- { UCOL_GREATER, UCOL_LESS, UCOL_GREATER, 0, UCOL_LESS, UCOL_LESS, 0, 0, UCOL_GREATER }
+ /* 'normal' befores */
- };
+ /*
+ * Note: With a "SPACE first primary" boundary CE in FractionalUCA.txt,
+ * it is not possible to tailor &[first primary ignorable]<a or &[last primary ignorable]<a
+ * because there is no tailoring space before that boundary.
+ * Made the tests work by tailoring to a space instead.
+ */
+ { "&[before 3][first primary ignorable]<<<c<<<b &' '<a", /* was &[first primary ignorable]<a */
+ { "c", "b", "\\u0332", "a" }, 4
+ },
- const static UColAttributeValue caseTestAttributes[][2] =
- {
- { UCOL_LOWER_FIRST, UCOL_OFF},
- { UCOL_UPPER_FIRST, UCOL_OFF},
- { UCOL_LOWER_FIRST, UCOL_ON},
- { UCOL_UPPER_FIRST, UCOL_ON}
+ /* we don't have a code point that corresponds to
+ * the last primary ignorable
+ */
+ { "&[before 3][last primary ignorable]<<<c<<<b &' '<a", /* was &[last primary ignorable]<a */
+ { "\\u0332", "\\u20e3", "c", "b", "a" }, 5
+ },
- };
- int32_t i,j,k;
- UErrorCode status = U_ZERO_ERROR;
- UCollationElements *iter;
- UCollator *myCollation;
- myCollation = ucol_open("en_US", &status);
+ { "&[before 3][first variable]<<<c<<<b &[first variable]<a",
+ { "c", "b", "\\u0009", "a", "\\u000a" }, 5
+ },
- if(U_FAILURE(status)){
- log_err("ERROR: in creation of rule based collator: %s\n", myErrorName(status));
- return;
- }
- log_verbose("Testing different case settings\n");
- ucol_setStrength(myCollation, UCOL_TERTIARY);
+ { "&[last variable]<a &[before 3][last variable]<<<c<<<b ",
+ { LAST_VARIABLE_CHAR_STRING, "c", "b", /* [last variable] */ "a", FIRST_REGULAR_CHAR_STRING }, 5
+ },
- for(k = 0; k<4; k++) {
- ucol_setAttribute(myCollation, UCOL_CASE_FIRST, caseTestAttributes[k][0], &status);
- ucol_setAttribute(myCollation, UCOL_CASE_LEVEL, caseTestAttributes[k][1], &status);
- log_verbose("Case first = %d, Case level = %d\n", caseTestAttributes[k][0], caseTestAttributes[k][1]);
- for (i = 0; i < 3 ; i++) {
- for(j = i+1; j<4; j++) {
- doTest(myCollation, testCase[i], testCase[j], caseTestResults[k][3*i+j-1]);
- }
- }
- }
- ucol_close(myCollation);
+ { "&[first regular]<a"
+ "&[before 1][first regular]<b",
+ { "b", FIRST_REGULAR_CHAR_STRING, "a", SECOND_REGULAR_CHAR_STRING }, 4
+ },
- myCollation = ucol_openRules(gRules, u_strlen(gRules), UCOL_OFF, UCOL_TERTIARY,NULL, &status);
- if(U_FAILURE(status)){
- log_err("ERROR: in creation of rule based collator: %s\n", myErrorName(status));
- return;
- }
- log_verbose("Testing different case settings with custom rules\n");
- ucol_setStrength(myCollation, UCOL_TERTIARY);
+ { "&[before 1][last regular]<b"
+ "&[last regular]<a",
+ { LAST_REGULAR_CHAR_STRING, "b", /* [last regular] */ "a", "\\u4e00" }, 4
+ },
- for(k = 0; k<4; k++) {
- ucol_setAttribute(myCollation, UCOL_CASE_FIRST, caseTestAttributes[k][0], &status);
- ucol_setAttribute(myCollation, UCOL_CASE_LEVEL, caseTestAttributes[k][1], &status);
- for (i = 0; i < 3 ; i++) {
- for(j = i+1; j<4; j++) {
- log_verbose("k:%d, i:%d, j:%d\n", k, i, j);
- doTest(myCollation, testCase[i], testCase[j], caseTestResults[k][3*i+j-1]);
- iter=ucol_openElements(myCollation, testCase[i], u_strlen(testCase[i]), &status);
- backAndForth(iter);
- ucol_closeElements(iter);
- iter=ucol_openElements(myCollation, testCase[j], u_strlen(testCase[j]), &status);
- backAndForth(iter);
- ucol_closeElements(iter);
- }
- }
+ { "&[before 1][first implicit]<b"
+ "&[first implicit]<a",
+ { "b", "\\u4e00", "a", "\\u4e01"}, 4
+ },
+#if 0 /* The current builder does not support tailoring to unassigned-implicit CEs (seems unnecessary, adds complexity). */
+ { "&[before 1][last implicit]<b"
+ "&[last implicit]<a",
+ { "b", "\\U0010FFFD", "a" }, 3
+ },
+#endif
+ { "&[last variable]<z"
+ "&' '<x" /* was &[last primary ignorable]<x, see above */
+ "&[last secondary ignorable]<<y"
+ "&[last tertiary ignorable]<<<w"
+ "&[top]<u",
+ {"\\ufffb", "w", "y", "\\u20e3", "x", LAST_VARIABLE_CHAR_STRING, "z", "u"}, 7
}
- ucol_close(myCollation);
- {
- const static char *lowerFirst[] = {
- "h",
- "H",
- "ch",
- "Ch",
- "CH",
- "cha",
- "chA",
- "Cha",
- "ChA",
- "CHa",
- "CHA",
- "i",
- "I"
- };
- const static char *upperFirst[] = {
- "H",
- "h",
- "CH",
- "Ch",
- "ch",
- "CHA",
- "CHa",
- "ChA",
- "Cha",
- "chA",
- "cha",
- "I",
- "i"
- };
- log_verbose("mixed case test\n");
- log_verbose("lower first, case level off\n");
- genericRulesStarter("[casefirst lower]&H<ch<<<Ch<<<CH", lowerFirst, sizeof(lowerFirst)/sizeof(lowerFirst[0]));
- log_verbose("upper first, case level off\n");
- genericRulesStarter("[casefirst upper]&H<ch<<<Ch<<<CH", upperFirst, sizeof(upperFirst)/sizeof(upperFirst[0]));
- log_verbose("lower first, case level on\n");
- genericRulesStarter("[casefirst lower][caselevel on]&H<ch<<<Ch<<<CH", lowerFirst, sizeof(lowerFirst)/sizeof(lowerFirst[0]));
- log_verbose("upper first, case level on\n");
- genericRulesStarter("[casefirst upper][caselevel on]&H<ch<<<Ch<<<CH", upperFirst, sizeof(upperFirst)/sizeof(upperFirst[0]));
- }
+ };
+ uint32_t i;
+ for(i = 0; i<UPRV_LENGTHOF(tests); i++) {
+ genericRulesStarter(tests[i].rules, tests[i].data, tests[i].len);
+ }
}
-static void TestIncrementalNormalize(void) {
-
- /*UChar baseA =0x61;*/
- UChar baseA =0x41;
-/* UChar baseB = 0x42;*/
- UChar ccMix[] = {0x316, 0x321, 0x300};
- /*UChar ccMix[] = {0x61, 0x61, 0x61};*/
- /*
- 0x316 is combining grave accent below, cc=220
- 0x321 is combining palatalized hook below, cc=202
- 0x300 is combining grave accent, cc=230
- */
-
- /*int maxSLen = 2000;*/
- int maxSLen = 64000;
- int sLen;
- int i;
-
- UCollator *coll;
- UErrorCode status = U_ZERO_ERROR;
- UCollationResult result;
- int32_t myQ = QUICK;
-
- if(QUICK < 0) {
- QUICK = 1;
- }
+static void TestOptimize(void) {
+ /* this is not really a test - just trying out
+ * whether copying of UCA contents will fail
+ * Cannot really test, since the functionality
+ * remains the same.
+ */
+ static const struct {
+ const char *rules;
+ const char *data[10];
+ const uint32_t len;
+ } tests[] = {
+ /* - all befores here amount to zero */
+ { "[optimize [\\uAC00-\\uD7FF]]",
+ { "a", "b"}, 2}
+ };
+ uint32_t i;
- {
- /* Test 1. Run very long unnormalized strings, to force overflow of*/
- /* most buffers along the way.*/
- UChar *strA;
- UChar *strB;
+ for(i = 0; i<UPRV_LENGTHOF(tests); i++) {
+ genericRulesStarter(tests[i].rules, tests[i].data, tests[i].len);
+ }
+}
- strA = malloc((maxSLen+1) * sizeof(UChar));
- strB = malloc((maxSLen+1) * sizeof(UChar));
+/*
+cycheng@ca.ibm.c... we got inconsistent results when using the UTF-16BE iterator and the UTF-8 iterator.
+weiv ucol_strcollIter?
+cycheng@ca.ibm.c... e.g. s1 = 0xfffc0062, and s2 = d8000021
+weiv these are the input strings?
+cycheng@ca.ibm.c... yes, using the utf-16 iterator and UCA with normalization on, we have s1 > s2
+weiv will check - could be a problem with utf-8 iterator
+cycheng@ca.ibm.c... but if we use the utf-8 iterator, i.e. s1 = efbfbc62 and s2 = eda08021, we have s1 < s2
+weiv hmmm
+cycheng@ca.ibm.c... note that we have a standalone high surrogate
+weiv that doesn't sound right
+cycheng@ca.ibm.c... we got the same inconsistent results on AIX and Win2000
+weiv so you have two strings, you convert them to utf-8 and to utf-16BE
+cycheng@ca.ibm.c... yes
+weiv and then do the comparison
+cycheng@ca.ibm.c... in one case, the input strings are in utf8, and in the other case the input strings are in utf-16be
+weiv utf-16 strings look like a little endian ones in the example you sent me
+weiv It could be a bug - let me try to test it out
+cycheng@ca.ibm.c... ok
+cycheng@ca.ibm.c... we can wait till the conf. call
+cycheng@ca.ibm.c... next weke
+weiv that would be great
+weiv hmmm
+weiv I might be wrong
+weiv let me play with it some more
+cycheng@ca.ibm.c... ok
+cycheng@ca.ibm.c... also please check s3 = 0x0e3a0062 and s4 = 0x0e400021. both are in utf-16be
+cycheng@ca.ibm.c... seems with icu 2.2 we have s3 > s4, but not in icu 2.4 that's built for db2
+cycheng@ca.ibm.c... also s1 & s2 that I sent you earlier are also in utf-16be
+weiv ok
+cycheng@ca.ibm.c... i ask sherman to send you more inconsistent data
+weiv thanks
+cycheng@ca.ibm.c... the 4 strings we sent are just samples
+*/
+#if 0
+static void Alexis(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *coll = ucol_open("", &status);
- coll = ucol_open("en_US", &status);
- if(status == U_FILE_ACCESS_ERROR) {
- log_data_err("Is your data around?\n");
- return;
- } else if(U_FAILURE(status)) {
- log_err("Error opening collator\n");
- return;
- }
- ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
- /*for (sLen = 257; sLen<maxSLen; sLen++) {*/
- /*for (sLen = 4; sLen<maxSLen; sLen++) {*/
- /*for (sLen = 1000; sLen<1001; sLen++) {*/
- for (sLen = 500; sLen<501; sLen++) {
- /*for (sLen = 40000; sLen<65000; sLen+=1000) {*/
- strA[0] = baseA;
- strB[0] = baseA;
- for (i=1; i<=sLen-1; i++) {
- strA[i] = ccMix[i % 3];
- strB[sLen-i] = ccMix[i % 3];
- }
- strA[sLen] = 0;
- strB[sLen] = 0;
+ const char utf16be[2][4] = {
+ { (char)0xd8, (char)0x00, (char)0x00, (char)0x21 },
+ { (char)0xff, (char)0xfc, (char)0x00, (char)0x62 }
+ };
- ucol_setStrength(coll, UCOL_TERTIARY); /* Do test with default strength, which runs*/
- doTest(coll, strA, strB, UCOL_EQUAL); /* optimized functions in the impl*/
- ucol_setStrength(coll, UCOL_IDENTICAL); /* Do again with the slow, general impl.*/
- doTest(coll, strA, strB, UCOL_EQUAL);
- }
- free(strA);
- free(strB);
- }
+ const char utf8[2][4] = {
+ { (char)0xed, (char)0xa0, (char)0x80, (char)0x21 },
+ { (char)0xef, (char)0xbf, (char)0xbc, (char)0x62 },
+ };
- QUICK = myQ;
+ UCharIterator iterU161, iterU162;
+ UCharIterator iterU81, iterU82;
+ UCollationResult resU16, resU8;
- /* Test 2: Non-normal sequence in a string that extends to the last character*/
- /* of the string. Checks a couple of edge cases.*/
+ uiter_setUTF16BE(&iterU161, utf16be[0], 4);
+ uiter_setUTF16BE(&iterU162, utf16be[1], 4);
- {
- UChar strA[] = {0x41, 0x41, 0x300, 0x316, 0};
- UChar strB[] = {0x41, 0xc0, 0x316, 0};
- ucol_setStrength(coll, UCOL_TERTIARY);
- doTest(coll, strA, strB, UCOL_EQUAL);
- }
+ uiter_setUTF8(&iterU81, utf8[0], 4);
+ uiter_setUTF8(&iterU82, utf8[1], 4);
- /* Test 3: Non-normal sequence is terminated by a surrogate pair.*/
+ ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
- {
- /* New UCA 3.1.1.
- * test below used a code point from Desseret, which sorts differently
- * than d800 dc00
- */
- /*UChar strA[] = {0x41, 0x41, 0x300, 0x316, 0xD801, 0xDC00, 0};*/
- UChar strA[] = {0x41, 0x41, 0x300, 0x316, 0xD800, 0xDC01, 0};
- UChar strB[] = {0x41, 0xc0, 0x316, 0xD800, 0xDC00, 0};
- ucol_setStrength(coll, UCOL_TERTIARY);
- doTest(coll, strA, strB, UCOL_GREATER);
- }
+ resU16 = ucol_strcollIter(coll, &iterU161, &iterU162, &status);
+ resU8 = ucol_strcollIter(coll, &iterU81, &iterU82, &status);
- /* Test 4: Imbedded nulls do not terminate a string when length is specified.*/
- {
- UChar strA[] = {0x41, 0x00, 0x42, 0x00};
- UChar strB[] = {0x41, 0x00, 0x00, 0x00};
- char sortKeyA[50];
- char sortKeyAz[50];
- char sortKeyB[50];
- char sortKeyBz[50];
- int r;
+ if(resU16 != resU8) {
+ log_err("different results\n");
+ }
- /* there used to be -3 here. Hmmmm.... */
- /*result = ucol_strcoll(coll, strA, -3, strB, -3);*/
- result = ucol_strcoll(coll, strA, 3, strB, 3);
- if (result != UCOL_GREATER) {
- log_err("ERROR 1 in test 4\n");
- }
- result = ucol_strcoll(coll, strA, -1, strB, -1);
- if (result != UCOL_EQUAL) {
- log_err("ERROR 2 in test 4\n");
- }
+ ucol_close(coll);
+}
+#endif
- ucol_getSortKey(coll, strA, 3, (uint8_t *)sortKeyA, sizeof(sortKeyA));
- ucol_getSortKey(coll, strA, -1, (uint8_t *)sortKeyAz, sizeof(sortKeyAz));
- ucol_getSortKey(coll, strB, 3, (uint8_t *)sortKeyB, sizeof(sortKeyB));
- ucol_getSortKey(coll, strB, -1, (uint8_t *)sortKeyBz, sizeof(sortKeyBz));
+#define CMSCOLL_ALEXIS2_BUFFER_SIZE 256
+static void Alexis2(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ UChar U16Source[CMSCOLL_ALEXIS2_BUFFER_SIZE], U16Target[CMSCOLL_ALEXIS2_BUFFER_SIZE];
+ char U16BESource[CMSCOLL_ALEXIS2_BUFFER_SIZE], U16BETarget[CMSCOLL_ALEXIS2_BUFFER_SIZE];
+ char U8Source[CMSCOLL_ALEXIS2_BUFFER_SIZE], U8Target[CMSCOLL_ALEXIS2_BUFFER_SIZE];
+ int32_t U16LenS = 0, U16LenT = 0, U16BELenS = 0, U16BELenT = 0, U8LenS = 0, U8LenT = 0;
- r = strcmp(sortKeyA, sortKeyAz);
- if (r <= 0) {
- log_err("Error 3 in test 4\n");
- }
- r = strcmp(sortKeyA, sortKeyB);
- if (r <= 0) {
- log_err("Error 4 in test 4\n");
- }
- r = strcmp(sortKeyAz, sortKeyBz);
- if (r != 0) {
- log_err("Error 5 in test 4\n");
- }
+ UConverter *conv = NULL;
- ucol_setStrength(coll, UCOL_IDENTICAL);
- ucol_getSortKey(coll, strA, 3, (uint8_t *)sortKeyA, sizeof(sortKeyA));
- ucol_getSortKey(coll, strA, -1, (uint8_t *)sortKeyAz, sizeof(sortKeyAz));
- ucol_getSortKey(coll, strB, 3, (uint8_t *)sortKeyB, sizeof(sortKeyB));
- ucol_getSortKey(coll, strB, -1, (uint8_t *)sortKeyBz, sizeof(sortKeyBz));
+ UCharIterator U16BEItS, U16BEItT;
+ UCharIterator U8ItS, U8ItT;
- r = strcmp(sortKeyA, sortKeyAz);
- if (r <= 0) {
- log_err("Error 6 in test 4\n");
- }
- r = strcmp(sortKeyA, sortKeyB);
- if (r <= 0) {
- log_err("Error 7 in test 4\n");
- }
- r = strcmp(sortKeyAz, sortKeyBz);
- if (r != 0) {
- log_err("Error 8 in test 4\n");
- }
- ucol_setStrength(coll, UCOL_TERTIARY);
- }
+ UCollationResult resU16, resU16BE, resU8;
+ static const char* const pairs[][2] = {
+ { "\\ud800\\u0021", "\\uFFFC\\u0062"},
+ { "\\u0435\\u0308\\u0334", "\\u0415\\u0334\\u0340" },
+ { "\\u0E40\\u0021", "\\u00A1\\u0021"},
+ { "\\u0E40\\u0021", "\\uFE57\\u0062"},
+ { "\\u5F20", "\\u5F20\\u4E00\\u8E3F"},
+ { "\\u0000\\u0020", "\\u0000\\u0020\\u0000"},
+ { "\\u0020", "\\u0020\\u0000"}
+/*
+5F20 (my result here)
+5F204E008E3F
+5F20 (your result here)
+*/
+ };
- /* Test 5: Null characters in non-normal source strings.*/
+ int32_t i = 0;
- {
- UChar strA[] = {0x41, 0x41, 0x300, 0x316, 0x00, 0x42, 0x00};
- UChar strB[] = {0x41, 0x41, 0x300, 0x316, 0x00, 0x00, 0x00};
- char sortKeyA[50];
- char sortKeyAz[50];
- char sortKeyB[50];
- char sortKeyBz[50];
- int r;
+ UCollator *coll = ucol_open("", &status);
+ if(status == U_FILE_ACCESS_ERROR) {
+ log_data_err("Is your data around?\n");
+ return;
+ } else if(U_FAILURE(status)) {
+ log_err("Error opening collator\n");
+ return;
+ }
+ ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
+ conv = ucnv_open("UTF16BE", &status);
+ for(i = 0; i < UPRV_LENGTHOF(pairs); i++) {
+ U16LenS = u_unescape(pairs[i][0], U16Source, CMSCOLL_ALEXIS2_BUFFER_SIZE);
+ U16LenT = u_unescape(pairs[i][1], U16Target, CMSCOLL_ALEXIS2_BUFFER_SIZE);
- result = ucol_strcoll(coll, strA, 6, strB, 6);
- if (result != UCOL_GREATER) {
- log_err("ERROR 1 in test 5\n");
- }
- result = ucol_strcoll(coll, strA, -1, strB, -1);
- if (result != UCOL_EQUAL) {
- log_err("ERROR 2 in test 5\n");
- }
+ resU16 = ucol_strcoll(coll, U16Source, U16LenS, U16Target, U16LenT);
- ucol_getSortKey(coll, strA, 6, (uint8_t *)sortKeyA, sizeof(sortKeyA));
- ucol_getSortKey(coll, strA, -1, (uint8_t *)sortKeyAz, sizeof(sortKeyAz));
- ucol_getSortKey(coll, strB, 6, (uint8_t *)sortKeyB, sizeof(sortKeyB));
- ucol_getSortKey(coll, strB, -1, (uint8_t *)sortKeyBz, sizeof(sortKeyBz));
+ log_verbose("Result of strcoll is %i\n", resU16);
- r = strcmp(sortKeyA, sortKeyAz);
- if (r <= 0) {
- log_err("Error 3 in test 5\n");
- }
- r = strcmp(sortKeyA, sortKeyB);
- if (r <= 0) {
- log_err("Error 4 in test 5\n");
- }
- r = strcmp(sortKeyAz, sortKeyBz);
- if (r != 0) {
- log_err("Error 5 in test 5\n");
- }
+ U16BELenS = ucnv_fromUChars(conv, U16BESource, CMSCOLL_ALEXIS2_BUFFER_SIZE, U16Source, U16LenS, &status);
+ U16BELenT = ucnv_fromUChars(conv, U16BETarget, CMSCOLL_ALEXIS2_BUFFER_SIZE, U16Target, U16LenT, &status);
+ (void)U16BELenS; /* Suppress set but not used warnings. */
+ (void)U16BELenT;
- ucol_setStrength(coll, UCOL_IDENTICAL);
- ucol_getSortKey(coll, strA, 6, (uint8_t *)sortKeyA, sizeof(sortKeyA));
- ucol_getSortKey(coll, strA, -1, (uint8_t *)sortKeyAz, sizeof(sortKeyAz));
- ucol_getSortKey(coll, strB, 6, (uint8_t *)sortKeyB, sizeof(sortKeyB));
- ucol_getSortKey(coll, strB, -1, (uint8_t *)sortKeyBz, sizeof(sortKeyBz));
+ /* use the original sizes, as the result from converter is in bytes */
+ uiter_setUTF16BE(&U16BEItS, U16BESource, U16LenS);
+ uiter_setUTF16BE(&U16BEItT, U16BETarget, U16LenT);
- r = strcmp(sortKeyA, sortKeyAz);
- if (r <= 0) {
- log_err("Error 6 in test 5\n");
- }
- r = strcmp(sortKeyA, sortKeyB);
- if (r <= 0) {
- log_err("Error 7 in test 5\n");
- }
- r = strcmp(sortKeyAz, sortKeyBz);
- if (r != 0) {
- log_err("Error 8 in test 5\n");
- }
- ucol_setStrength(coll, UCOL_TERTIARY);
+ resU16BE = ucol_strcollIter(coll, &U16BEItS, &U16BEItT, &status);
+
+ log_verbose("Result of U16BE is %i\n", resU16BE);
+
+ if(resU16 != resU16BE) {
+ log_verbose("Different results between UTF16 and UTF16BE for %s & %s\n", pairs[i][0], pairs[i][1]);
}
+ u_strToUTF8(U8Source, CMSCOLL_ALEXIS2_BUFFER_SIZE, &U8LenS, U16Source, U16LenS, &status);
+ u_strToUTF8(U8Target, CMSCOLL_ALEXIS2_BUFFER_SIZE, &U8LenT, U16Target, U16LenT, &status);
- /* Test 6: Null character as base of a non-normal combining sequence.*/
+ uiter_setUTF8(&U8ItS, U8Source, U8LenS);
+ uiter_setUTF8(&U8ItT, U8Target, U8LenT);
- {
- UChar strA[] = {0x41, 0x0, 0x300, 0x316, 0x41, 0x302, 0x00};
- UChar strB[] = {0x41, 0x0, 0x302, 0x316, 0x41, 0x300, 0x00};
+ resU8 = ucol_strcollIter(coll, &U8ItS, &U8ItT, &status);
- result = ucol_strcoll(coll, strA, 5, strB, 5);
- if (result != UCOL_LESS) {
- log_err("Error 1 in test 6\n");
- }
- result = ucol_strcoll(coll, strA, -1, strB, -1);
- if (result != UCOL_EQUAL) {
- log_err("Error 2 in test 6\n");
- }
+ if(resU16 != resU8) {
+ log_verbose("Different results between UTF16 and UTF8 for %s & %s\n", pairs[i][0], pairs[i][1]);
}
- ucol_close(coll);
-}
-
+ }
+ ucol_close(coll);
+ ucnv_close(conv);
+}
-#if 0
-static void TestGetCaseBit(void) {
- static const char *caseBitData[] = {
- "a", "A", "ch", "Ch", "CH",
- "\\uFF9E", "\\u0009"
+static void TestHebrewUCA(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ static const char *first[] = {
+ "d790d6b8d79cd795d6bcd7a9",
+ "d790d79cd79ed7a7d799d799d7a1",
+ "d790d6b4d79ed795d6bcd7a9",
};
- static const uint8_t results[] = {
- UCOL_LOWER_CASE, UCOL_UPPER_CASE, UCOL_LOWER_CASE, UCOL_MIXED_CASE, UCOL_UPPER_CASE,
- UCOL_UPPER_CASE, UCOL_LOWER_CASE
- };
+ char utf8String[3][256];
+ UChar utf16String[3][256];
- uint32_t i, blen = 0;
- UChar b[256] = {0};
- UErrorCode status = U_ZERO_ERROR;
- UCollator *UCA = ucol_open("", &status);
- uint8_t res = 0;
+ int32_t i = 0, j = 0;
+ int32_t sizeUTF8[3];
+ int32_t sizeUTF16[3];
- for(i = 0; i<sizeof(results)/sizeof(results[0]); i++) {
- blen = u_unescape(caseBitData[i], b, 256);
- res = ucol_uprv_getCaseBits(UCA, b, blen, &status);
- if(results[i] != res) {
- log_err("Expected case = %02X, got %02X for %04X\n", results[i], res, b[0]);
+ UCollator *coll = ucol_open("", &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "Could not open UCA collation %s\n", u_errorName(status));
+ return;
+ }
+ /*ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);*/
+
+ for(i = 0; i < UPRV_LENGTHOF(first); i++) {
+ sizeUTF8[i] = u_parseUTF8(first[i], -1, utf8String[i], 256, &status);
+ u_strFromUTF8(utf16String[i], 256, &sizeUTF16[i], utf8String[i], sizeUTF8[i], &status);
+ log_verbose("%i: ");
+ for(j = 0; j < sizeUTF16[i]; j++) {
+ /*log_verbose("\\u%04X", utf16String[i][j]);*/
+ log_verbose("%04X", utf16String[i][j]);
+ }
+ log_verbose("\n");
+ }
+ for(i = 0; i < UPRV_LENGTHOF(first)-1; i++) {
+ for(j = i + 1; j < UPRV_LENGTHOF(first); j++) {
+ doTest(coll, utf16String[i], utf16String[j], UCOL_LESS);
}
}
-}
-#endif
-static void TestHangulTailoring(void) {
- static const char *koreanData[] = {
- "\\uac00", "\\u4f3d", "\\u4f73", "\\u5047", "\\u50f9", "\\u52a0", "\\u53ef", "\\u5475",
- "\\u54e5", "\\u5609", "\\u5ac1", "\\u5bb6", "\\u6687", "\\u67b6", "\\u67b7", "\\u67ef",
- "\\u6b4c", "\\u73c2", "\\u75c2", "\\u7a3c", "\\u82db", "\\u8304", "\\u8857", "\\u8888",
- "\\u8a36", "\\u8cc8", "\\u8dcf", "\\u8efb", "\\u8fe6", "\\u99d5",
- "\\u4EEE", "\\u50A2", "\\u5496", "\\u54FF", "\\u5777", "\\u5B8A", "\\u659D", "\\u698E",
- "\\u6A9F", "\\u73C8", "\\u7B33", "\\u801E", "\\u8238", "\\u846D", "\\u8B0C"
- };
+ ucol_close(coll);
- const char *rules =
- "&\\uac00 <<< \\u4f3d <<< \\u4f73 <<< \\u5047 <<< \\u50f9 <<< \\u52a0 <<< \\u53ef <<< \\u5475 "
- "<<< \\u54e5 <<< \\u5609 <<< \\u5ac1 <<< \\u5bb6 <<< \\u6687 <<< \\u67b6 <<< \\u67b7 <<< \\u67ef "
- "<<< \\u6b4c <<< \\u73c2 <<< \\u75c2 <<< \\u7a3c <<< \\u82db <<< \\u8304 <<< \\u8857 <<< \\u8888 "
- "<<< \\u8a36 <<< \\u8cc8 <<< \\u8dcf <<< \\u8efb <<< \\u8fe6 <<< \\u99d5 "
- "<<< \\u4EEE <<< \\u50A2 <<< \\u5496 <<< \\u54FF <<< \\u5777 <<< \\u5B8A <<< \\u659D <<< \\u698E "
- "<<< \\u6A9F <<< \\u73C8 <<< \\u7B33 <<< \\u801E <<< \\u8238 <<< \\u846D <<< \\u8B0C";
+}
+
+static void TestPartialSortKeyTermination(void) {
+ static const char* cases[] = {
+ "\\u1234\\u1234\\udc00",
+ "\\udc00\\ud800\\ud800"
+ };
+ int32_t i;
UErrorCode status = U_ZERO_ERROR;
- UChar rlz[2048] = { 0 };
- uint32_t rlen = u_unescape(rules, rlz, 2048);
- UCollator *coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &status);
- if(status == U_FILE_ACCESS_ERROR) {
- log_data_err("Is your data around?\n");
- return;
- } else if(U_FAILURE(status)) {
- log_err("Error opening collator\n");
- return;
- }
+ UCollator *coll = ucol_open("", &status);
- log_verbose("Using start of korean rules\n");
+ UCharIterator iter;
- if(U_SUCCESS(status)) {
- genericOrderingTest(coll, koreanData, sizeof(koreanData)/sizeof(koreanData[0]));
- } else {
- log_err("Unable to open collator with rules %s\n", rules);
- }
+ UChar currCase[256];
+ int32_t length = 0;
+ int32_t pKeyLen = 0;
- log_verbose("Setting jamoSpecial to TRUE and testing once more\n");
- ((UCATableHeader *)coll->image)->jamoSpecial = TRUE; /* don't try this at home */
- genericOrderingTest(coll, koreanData, sizeof(koreanData)/sizeof(koreanData[0]));
+ uint8_t key[256];
- ucol_close(coll);
+ for(i = 0; i < UPRV_LENGTHOF(cases); i++) {
+ uint32_t state[2] = {0, 0};
+ length = u_unescape(cases[i], currCase, 256);
+ uiter_setString(&iter, currCase, length);
+ pKeyLen = ucol_nextSortKeyPart(coll, &iter, state, key, 256, &status);
+ (void)pKeyLen; /* Suppress set but not used warning. */
- log_verbose("Using ko__LOTUS locale\n");
- genericLocaleStarter("ko__LOTUS", koreanData, sizeof(koreanData)/sizeof(koreanData[0]));
+ log_verbose("Done\n");
+
+ }
+ ucol_close(coll);
}
-static void TestCompressOverlap(void) {
- UChar secstr[150];
- UChar tertstr[150];
- UErrorCode status = U_ZERO_ERROR;
- UCollator *coll;
- char result[200];
- uint32_t resultlen;
- int count = 0;
- char *tempptr;
+static void TestSettings(void) {
+ static const char* cases[] = {
+ "apple",
+ "Apple"
+ };
- coll = ucol_open("", &status);
+ static const char* locales[] = {
+ "",
+ "en"
+ };
- if (U_FAILURE(status)) {
- log_err("Collator can't be created\n");
- return;
- }
- while (count < 149) {
- secstr[count] = 0x0020; /* [06, 05, 05] */
- tertstr[count] = 0x0020;
- count ++;
+ UErrorCode status = U_ZERO_ERROR;
+
+ int32_t i = 0, j = 0;
+
+ UChar source[256], target[256];
+ int32_t sLen = 0, tLen = 0;
+
+ UCollator *collateObject = NULL;
+ for(i = 0; i < UPRV_LENGTHOF(locales); i++) {
+ collateObject = ucol_open(locales[i], &status);
+ ucol_setStrength(collateObject, UCOL_PRIMARY);
+ ucol_setAttribute(collateObject, UCOL_CASE_LEVEL , UCOL_OFF, &status);
+ for(j = 1; j < UPRV_LENGTHOF(cases); j++) {
+ sLen = u_unescape(cases[j-1], source, 256);
+ source[sLen] = 0;
+ tLen = u_unescape(cases[j], target, 256);
+ source[tLen] = 0;
+ doTest(collateObject, source, target, UCOL_EQUAL);
}
+ ucol_close(collateObject);
+ }
+}
- /* top down compression ----------------------------------- */
- secstr[count] = 0x0332; /* [, 87, 05] */
- tertstr[count] = 0x3000; /* [06, 05, 07] */
+static int32_t TestEqualsForCollator(const char* locName, UCollator *source, UCollator *target) {
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t errorNo = 0;
+ const UChar *sourceRules = NULL;
+ int32_t sourceRulesLen = 0;
+ UParseError parseError;
+ UColAttributeValue french = UCOL_OFF;
- /* no compression secstr should have 150 secondary bytes, tertstr should
- have 150 tertiary bytes.
- with correct overlapping compression, secstr should have 4 secondary
- bytes, tertstr should have > 2 tertiary bytes */
- resultlen = ucol_getSortKey(coll, secstr, 150, (uint8_t *)result, 250);
- tempptr = uprv_strchr(result, 1) + 1;
- while (*(tempptr + 1) != 1) {
- /* the last secondary collation element is not checked since it is not
- part of the compression */
- if (*tempptr < UCOL_COMMON_TOP2 - UCOL_TOP_COUNT2) {
- log_err("Secondary compression overlapped\n");
+ if(!ucol_equals(source, target)) {
+ log_err("Same collators, different address not equal\n");
+ errorNo++;
+ }
+ ucol_close(target);
+ if(uprv_strcmp(locName, ucol_getLocaleByType(source, ULOC_ACTUAL_LOCALE, &status)) == 0) {
+ target = ucol_safeClone(source, NULL, NULL, &status);
+ if(U_FAILURE(status)) {
+ log_err("Error creating clone\n");
+ errorNo++;
+ return errorNo;
}
- tempptr ++;
+ if(!ucol_equals(source, target)) {
+ log_err("Collator different from it's clone\n");
+ errorNo++;
+ }
+ french = ucol_getAttribute(source, UCOL_FRENCH_COLLATION, &status);
+ if(french == UCOL_ON) {
+ ucol_setAttribute(target, UCOL_FRENCH_COLLATION, UCOL_OFF, &status);
+ } else {
+ ucol_setAttribute(target, UCOL_FRENCH_COLLATION, UCOL_ON, &status);
+ }
+ if(U_FAILURE(status)) {
+ log_err("Error setting attributes\n");
+ errorNo++;
+ return errorNo;
+ }
+ if(ucol_equals(source, target)) {
+ log_err("Collators same even when options changed\n");
+ errorNo++;
+ }
+ ucol_close(target);
+
+ sourceRules = ucol_getRules(source, &sourceRulesLen);
+ target = ucol_openRules(sourceRules, sourceRulesLen, UCOL_DEFAULT, UCOL_DEFAULT, &parseError, &status);
+ if(U_FAILURE(status)) {
+ log_err("Error instantiating target from rules - %s\n", u_errorName(status));
+ errorNo++;
+ return errorNo;
+ }
+ /* Note: The tailoring rule string is an optional data item. */
+ if(!ucol_equals(source, target) && sourceRulesLen != 0) {
+ log_err("Collator different from collator that was created from the same rules\n");
+ errorNo++;
+ }
+ ucol_close(target);
}
+ return errorNo;
+}
- /* tertiary top/bottom/common for en_US is similar to the secondary
- top/bottom/common */
- resultlen = ucol_getSortKey(coll, tertstr, 150, (uint8_t *)result, 250);
- tempptr = uprv_strrchr(result, 1) + 1;
- while (*(tempptr + 1) != 0) {
- /* the last secondary collation element is not checked since it is not
- part of the compression */
- if (*tempptr < coll->tertiaryTop - coll->tertiaryTopCount) {
- log_err("Tertiary compression overlapped\n");
- }
- tempptr ++;
+
+static void TestEquals(void) {
+ /* ucol_equals is not currently a public API. There is a chance that it will become
+ * something like this.
+ */
+ /* test whether the two collators instantiated from the same locale are equal */
+ UErrorCode status = U_ZERO_ERROR;
+ UParseError parseError;
+ int32_t noOfLoc = uloc_countAvailable();
+ const char *locName = NULL;
+ UCollator *source = NULL, *target = NULL;
+ int32_t i = 0;
+
+ const char* rules[] = {
+ "&l < lj <<< Lj <<< LJ",
+ "&n < nj <<< Nj <<< NJ",
+ "&ae <<< \\u00e4",
+ "&AE <<< \\u00c4"
+ };
+ /*
+ const char* badRules[] = {
+ "&l <<< Lj",
+ "&n < nj <<< nJ <<< NJ",
+ "&a <<< \\u00e4",
+ "&AE <<< \\u00c4 <<< x"
+ };
+ */
+
+ UChar sourceRules[1024], targetRules[1024];
+ int32_t sourceRulesSize = 0, targetRulesSize = 0;
+ int32_t rulesSize = UPRV_LENGTHOF(rules);
+
+ for(i = 0; i < rulesSize; i++) {
+ sourceRulesSize += u_unescape(rules[i], sourceRules+sourceRulesSize, 1024 - sourceRulesSize);
+ targetRulesSize += u_unescape(rules[rulesSize-i-1], targetRules+targetRulesSize, 1024 - targetRulesSize);
}
- /* bottom up compression ------------------------------------- */
- secstr[count] = 0;
- tertstr[count] = 0;
- resultlen = ucol_getSortKey(coll, secstr, 150, (uint8_t *)result, 250);
- tempptr = uprv_strchr(result, 1) + 1;
- while (*(tempptr + 1) != 1) {
- /* the last secondary collation element is not checked since it is not
- part of the compression */
- if (*tempptr > UCOL_COMMON_BOT2 + UCOL_BOT_COUNT2) {
- log_err("Secondary compression overlapped\n");
- }
- tempptr ++;
+ source = ucol_openRules(sourceRules, sourceRulesSize, UCOL_DEFAULT, UCOL_DEFAULT, &parseError, &status);
+ if(status == U_FILE_ACCESS_ERROR) {
+ log_data_err("Is your data around?\n");
+ return;
+ } else if(U_FAILURE(status)) {
+ log_err("Error opening collator\n");
+ return;
+ }
+ target = ucol_openRules(targetRules, targetRulesSize, UCOL_DEFAULT, UCOL_DEFAULT, &parseError, &status);
+ if(!ucol_equals(source, target)) {
+ log_err("Equivalent collators not equal!\n");
}
+ ucol_close(source);
+ ucol_close(target);
- /* tertiary top/bottom/common for en_US is similar to the secondary
- top/bottom/common */
- resultlen = ucol_getSortKey(coll, tertstr, 150, (uint8_t *)result, 250);
- tempptr = uprv_strrchr(result, 1) + 1;
- while (*(tempptr + 1) != 0) {
- /* the last secondary collation element is not checked since it is not
- part of the compression */
- if (*tempptr > coll->tertiaryBottom + coll->tertiaryBottomCount) {
- log_err("Tertiary compression overlapped\n");
+ source = ucol_open("root", &status);
+ target = ucol_open("root", &status);
+ log_verbose("Testing root\n");
+ if(!ucol_equals(source, source)) {
+ log_err("Same collator not equal\n");
+ }
+ if(TestEqualsForCollator("root", source, target)) {
+ log_err("Errors for root\n");
+ }
+ ucol_close(source);
+
+ for(i = 0; i<noOfLoc; i++) {
+ status = U_ZERO_ERROR;
+ locName = uloc_getAvailable(i);
+ /*if(hasCollationElements(locName)) {*/
+ log_verbose("Testing equality for locale %s\n", locName);
+ source = ucol_open(locName, &status);
+ target = ucol_open(locName, &status);
+ if (U_FAILURE(status)) {
+ log_err("Error opening collator for locale %s %s\n", locName, u_errorName(status));
+ continue;
+ }
+ if(TestEqualsForCollator(locName, source, target)) {
+ log_err("Errors for locale %s\n", locName);
}
- tempptr ++;
+ ucol_close(source);
+ /*}*/
}
+}
+static void TestJ2726(void) {
+ UChar a[2] = { 0x61, 0x00 }; /*"a"*/
+ UChar aSpace[3] = { 0x61, 0x20, 0x00 }; /*"a "*/
+ UChar spaceA[3] = { 0x20, 0x61, 0x00 }; /*" a"*/
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *coll = ucol_open("en", &status);
+ ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
+ ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_PRIMARY, &status);
+ doTest(coll, a, aSpace, UCOL_EQUAL);
+ doTest(coll, aSpace, a, UCOL_EQUAL);
+ doTest(coll, a, spaceA, UCOL_EQUAL);
+ doTest(coll, spaceA, a, UCOL_EQUAL);
+ doTest(coll, spaceA, aSpace, UCOL_EQUAL);
+ doTest(coll, aSpace, spaceA, UCOL_EQUAL);
ucol_close(coll);
}
-static void TestCyrillicTailoring(void) {
- static const char *test[] = {
- "\\u0410b",
- "\\u0410\\u0306a",
- "\\u04d0A"
- };
-
- /* Russian overrides contractions, so this test is not valid anymore */
- /*genericLocaleStarter("ru", test, 3);*/
-
- genericLocaleStarter("root", test, 3);
- genericRulesStarter("&\\u0410 = \\u0410", test, 3);
- genericRulesStarter("&Z < \\u0410", test, 3);
- genericRulesStarter("&\\u0410 = \\u0410 < \\u04d0", test, 3);
- genericRulesStarter("&Z < \\u0410 < \\u04d0", test, 3);
- genericRulesStarter("&\\u0410 = \\u0410 < \\u0410\\u0301", test, 3);
- genericRulesStarter("&Z < \\u0410 < \\u0410\\u0301", test, 3);
+static void NullRule(void) {
+ UChar r[3] = {0};
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *coll = ucol_openRules(r, 1, UCOL_DEFAULT, UCOL_DEFAULT, NULL, &status);
+ if(U_SUCCESS(status)) {
+ log_err("This should have been an error!\n");
+ ucol_close(coll);
+ } else {
+ status = U_ZERO_ERROR;
+ }
+ coll = ucol_openRules(r, 0, UCOL_DEFAULT, UCOL_DEFAULT, NULL, &status);
+ if(U_FAILURE(status)) {
+ log_err_status(status, "Empty rules should have produced a valid collator -> %s\n", u_errorName(status));
+ } else {
+ ucol_close(coll);
+ }
}
-static void TestSuppressContractions(void) {
+/**
+ * Test for CollationElementIterator previous and next for the whole set of
+ * unicode characters with normalization on.
+ */
+static void TestNumericCollation(void)
+{
+ UErrorCode status = U_ZERO_ERROR;
- static const char *testNoCont2[] = {
- "\\u0410\\u0302a",
- "\\u0410\\u0306b",
- "\\u0410c"
- };
- static const char *testNoCont[] = {
- "a\\u0410",
- "A\\u0410\\u0306",
- "\\uFF21\\u0410\\u0302"
- };
+ const static char *basicTestStrings[]={
+ "hello1",
+ "hello2",
+ "hello2002",
+ "hello2003",
+ "hello123456",
+ "hello1234567",
+ "hello10000000",
+ "hello100000000",
+ "hello1000000000",
+ "hello10000000000",
+ };
- genericRulesStarter("[suppressContractions [\\u0400-\\u047f]]", testNoCont, 3);
- genericRulesStarter("[suppressContractions [\\u0400-\\u047f]]", testNoCont2, 3);
-}
+ const static char *preZeroTestStrings[]={
+ "avery10000",
+ "avery010000",
+ "avery0010000",
+ "avery00010000",
+ "avery000010000",
+ "avery0000010000",
+ "avery00000010000",
+ "avery000000010000",
+ };
-static void TestContraction(void) {
- const static char *testrules[] = {
- "&A = AB / B",
- "&A = A\\u0306/\\u0306",
- "&c = ch / h"
+ const static char *thirtyTwoBitNumericStrings[]={
+ "avery42949672960",
+ "avery42949672961",
+ "avery42949672962",
+ "avery429496729610"
};
- const static UChar testdata[][2] = {
- {0x0041 /* 'A' */, 0x0042 /* 'B' */},
- {0x0041 /* 'A' */, 0x0306 /* combining breve */},
- {0x0063 /* 'c' */, 0x0068 /* 'h' */}
+
+ const static char *longNumericStrings[]={
+ /* Some of these sort out of the order that would expected if digits-as-numbers handled arbitrarily-long digit strings.
+ In fact, a single collation element can represent a maximum of 254 digits as a number. Digit strings longer than that
+ are treated as multiple collation elements. */
+ "num9234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123z", /*253digits, num + 9.23E252 + z */
+ "num10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", /*254digits, num + 1.00E253 */
+ "num100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", /*255digits, num + 1.00E253 + 0, out of numeric order but expected */
+ "num12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234", /*254digits, num + 1.23E253 */
+ "num123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", /*255digits, num + 1.23E253 + 5 */
+ "num1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456", /*256digits, num + 1.23E253 + 56 */
+ "num12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567", /*257digits, num + 1.23E253 + 567 */
+ "num12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234a", /*254digits, num + 1.23E253 + a, out of numeric order but expected */
+ "num92345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234", /*254digits, num + 9.23E253, out of numeric order but expected */
+ "num92345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234a", /*254digits, num + 9.23E253 + a, out of numeric order but expected */
};
- const static UChar testdata2[][2] = {
- {0x0063 /* 'c' */, 0x0067 /* 'g' */},
- {0x0063 /* 'c' */, 0x0068 /* 'h' */},
- {0x0063 /* 'c' */, 0x006C /* 'l' */}
+
+ const static char *supplementaryDigits[] = {
+ "\\uD835\\uDFCE", /* 0 */
+ "\\uD835\\uDFCF", /* 1 */
+ "\\uD835\\uDFD0", /* 2 */
+ "\\uD835\\uDFD1", /* 3 */
+ "\\uD835\\uDFCF\\uD835\\uDFCE", /* 10 */
+ "\\uD835\\uDFCF\\uD835\\uDFCF", /* 11 */
+ "\\uD835\\uDFCF\\uD835\\uDFD0", /* 12 */
+ "\\uD835\\uDFD0\\uD835\\uDFCE", /* 20 */
+ "\\uD835\\uDFD0\\uD835\\uDFCF", /* 21 */
+ "\\uD835\\uDFD0\\uD835\\uDFD0" /* 22 */
};
- const static char *testrules3[] = {
- "&z < xyz &xyzw << B",
- "&z < xyz &xyz << B / w",
- "&z < ch &achm << B",
- "&z < ch &a << B / chm",
- "&\\ud800\\udc00w << B",
- "&\\ud800\\udc00 << B / w",
- "&a\\ud800\\udc00m << B",
- "&a << B / \\ud800\\udc00m",
+
+ const static char *foreignDigits[] = {
+ "\\u0661",
+ "\\u0662",
+ "\\u0663",
+ "\\u0661\\u0660",
+ "\\u0661\\u0662",
+ "\\u0661\\u0663",
+ "\\u0662\\u0660",
+ "\\u0662\\u0662",
+ "\\u0662\\u0663",
+ "\\u0663\\u0660",
+ "\\u0663\\u0662",
+ "\\u0663\\u0663"
};
- UErrorCode status = U_ZERO_ERROR;
- UCollator *coll;
- UChar rule[256] = {0};
- uint32_t rlen = 0;
- int i;
+ const static char *evenZeroes[] = {
+ "2000",
+ "2001",
+ "2002",
+ "2003"
+ };
- for (i = 0; i < sizeof(testrules) / sizeof(testrules[0]); i ++) {
- UCollationElements *iter1;
- int j = 0;
- log_verbose("Rule %s for testing\n", testrules[i]);
- rlen = u_unescape(testrules[i], rule, 32);
- coll = ucol_openRules(rule, rlen, UCOL_ON, UCOL_TERTIARY,NULL, &status);
- if (U_FAILURE(status)) {
- log_err("Collator creation failed %s\n", testrules[i]);
- return;
- }
- iter1 = ucol_openElements(coll, testdata[i], 2, &status);
- if (U_FAILURE(status)) {
- log_err("Collation iterator creation failed\n");
- return;
- }
- while (j < 2) {
- UCollationElements *iter2 = ucol_openElements(coll,
- &(testdata[i][j]),
- 1, &status);
- uint32_t ce;
- if (U_FAILURE(status)) {
- log_err("Collation iterator creation failed\n");
- return;
- }
- ce = ucol_next(iter2, &status);
- while (ce != UCOL_NULLORDER) {
- if ((uint32_t)ucol_next(iter1, &status) != ce) {
- log_err("Collation elements in contraction split does not match\n");
- return;
- }
- ce = ucol_next(iter2, &status);
- }
- j ++;
- ucol_closeElements(iter2);
- }
- if (ucol_next(iter1, &status) != UCOL_NULLORDER) {
- log_err("Collation elements not exhausted\n");
- return;
- }
- ucol_closeElements(iter1);
- ucol_close(coll);
- }
+ UColAttribute att = UCOL_NUMERIC_COLLATION;
+ UColAttributeValue val = UCOL_ON;
- rlen = u_unescape("& a < b < c < ch < d & c = ch / h", rule, 256);
- coll = ucol_openRules(rule, rlen, UCOL_ON, UCOL_TERTIARY,NULL, &status);
- if (ucol_strcoll(coll, testdata2[0], 2, testdata2[1], 2) != UCOL_LESS) {
- log_err("Expected \\u%04x\\u%04x < \\u%04x\\u%04x\n",
- testdata2[0][0], testdata2[0][1], testdata2[1][0],
- testdata2[1][1]);
+ /* Open our collator. */
+ UCollator* coll = ucol_open("root", &status);
+ if (U_FAILURE(status)){
+ log_err_status(status, "ERROR: in using ucol_open() -> %s\n",
+ myErrorName(status));
return;
}
- if (ucol_strcoll(coll, testdata2[1], 2, testdata2[2], 2) != UCOL_LESS) {
- log_err("Expected \\u%04x\\u%04x < \\u%04x\\u%04x\n",
- testdata2[1][0], testdata2[1][1], testdata2[2][0],
- testdata2[2][1]);
+ genericLocaleStarterWithOptions("root", basicTestStrings, UPRV_LENGTHOF(basicTestStrings), &att, &val, 1);
+ genericLocaleStarterWithOptions("root", thirtyTwoBitNumericStrings, UPRV_LENGTHOF(thirtyTwoBitNumericStrings), &att, &val, 1);
+ genericLocaleStarterWithOptions("root", longNumericStrings, UPRV_LENGTHOF(longNumericStrings), &att, &val, 1);
+ genericLocaleStarterWithOptions("en_US", foreignDigits, UPRV_LENGTHOF(foreignDigits), &att, &val, 1);
+ genericLocaleStarterWithOptions("root", supplementaryDigits, UPRV_LENGTHOF(supplementaryDigits), &att, &val, 1);
+ genericLocaleStarterWithOptions("root", evenZeroes, UPRV_LENGTHOF(evenZeroes), &att, &val, 1);
+
+ /* Setting up our collator to do digits. */
+ ucol_setAttribute(coll, UCOL_NUMERIC_COLLATION, UCOL_ON, &status);
+ if (U_FAILURE(status)){
+ log_err("ERROR: in setting UCOL_NUMERIC_COLLATION as an attribute\n %s\n",
+ myErrorName(status));
return;
}
+
+ /*
+ Testing that prepended zeroes still yield the correct collation behavior.
+ We expect that every element in our strings array will be equal.
+ */
+ genericOrderingTestWithResult(coll, preZeroTestStrings, UPRV_LENGTHOF(preZeroTestStrings), UCOL_EQUAL);
+
ucol_close(coll);
+}
- for (i = 0; i < sizeof(testrules3) / sizeof(testrules3[0]); i += 2) {
- UCollator *coll1,
- *coll2;
- UCollationElements *iter1,
- *iter2;
- UChar ch = 0x0042 /* 'B' */;
- uint32_t ce;
- rlen = u_unescape(testrules3[i], rule, 32);
- coll1 = ucol_openRules(rule, rlen, UCOL_ON, UCOL_TERTIARY,NULL, &status);
- rlen = u_unescape(testrules3[i + 1], rule, 32);
- coll2 = ucol_openRules(rule, rlen, UCOL_ON, UCOL_TERTIARY,NULL, &status);
- if (U_FAILURE(status)) {
- log_err("Collator creation failed %s\n", testrules[i]);
- return;
- }
- iter1 = ucol_openElements(coll1, &ch, 1, &status);
- iter2 = ucol_openElements(coll2, &ch, 1, &status);
- if (U_FAILURE(status)) {
- log_err("Collation iterator creation failed\n");
- return;
- }
- ce = ucol_next(iter1, &status);
- if (U_FAILURE(status)) {
- log_err("Retrieving ces failed\n");
- return;
- }
- while (ce != UCOL_NULLORDER) {
- if (ce != (uint32_t)ucol_next(iter2, &status)) {
- log_err("CEs does not match\n");
- return;
- }
- ce = ucol_next(iter1, &status);
- if (U_FAILURE(status)) {
- log_err("Retrieving ces failed\n");
- return;
- }
- }
- if (ucol_next(iter2, &status) != UCOL_NULLORDER) {
- log_err("CEs not exhausted\n");
- return;
+static void TestTibetanConformance(void)
+{
+ const char* test[] = {
+ "\\u0FB2\\u0591\\u0F71\\u0061",
+ "\\u0FB2\\u0F71\\u0061"
+ };
+
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *coll = ucol_open("", &status);
+ UChar source[100];
+ UChar target[100];
+ int result;
+ ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
+ if (U_SUCCESS(status)) {
+ u_unescape(test[0], source, 100);
+ u_unescape(test[1], target, 100);
+ doTest(coll, source, target, UCOL_EQUAL);
+ result = ucol_strcoll(coll, source, -1, target, -1);
+ log_verbose("result %d\n", result);
+ if (UCOL_EQUAL != result) {
+ log_err("Tibetan comparison error\n");
}
- ucol_closeElements(iter1);
- ucol_closeElements(iter2);
- ucol_close(coll1);
- ucol_close(coll2);
}
+ ucol_close(coll);
+
+ genericLocaleStarterWithResult("", test, 2, UCOL_EQUAL);
}
-static void TestExpansion(void) {
- const static char *testrules[] = {
- "&J << K / B & K << M",
- "&J << K / B << M"
- };
- const static UChar testdata[][3] = {
- {0x004A /*'J'*/, 0x0041 /*'A'*/, 0},
- {0x004D /*'M'*/, 0x0041 /*'A'*/, 0},
- {0x004B /*'K'*/, 0x0041 /*'A'*/, 0},
- {0x004B /*'K'*/, 0x0043 /*'C'*/, 0},
- {0x004A /*'J'*/, 0x0043 /*'C'*/, 0},
- {0x004D /*'M'*/, 0x0043 /*'C'*/, 0}
- };
+static void TestPinyinProblem(void) {
+ static const char *test[] = { "\\u4E56\\u4E56\\u7761", "\\u4E56\\u5B69\\u5B50" };
+ genericLocaleStarter("zh__PINYIN", test, UPRV_LENGTHOF(test));
+}
- UErrorCode status = U_ZERO_ERROR;
- UCollator *coll;
- UChar rule[256] = {0};
- uint32_t rlen = 0;
- int i;
+/**
+ * Iterate through the given iterator, checking to see that all the strings
+ * in the expected array are present.
+ * @param expected array of strings we expect to see, or NULL
+ * @param expectedCount number of elements of expected, or 0
+ */
+static int32_t checkUEnumeration(const char* msg,
+ UEnumeration* iter,
+ const char** expected,
+ int32_t expectedCount) {
+ UErrorCode ec = U_ZERO_ERROR;
+ int32_t i = 0, n, j, bit;
+ int32_t seenMask = 0;
- for (i = 0; i < sizeof(testrules) / sizeof(testrules[0]); i ++) {
- int j = 0;
- log_verbose("Rule %s for testing\n", testrules[i]);
- rlen = u_unescape(testrules[i], rule, 32);
- coll = ucol_openRules(rule, rlen, UCOL_ON, UCOL_TERTIARY,NULL, &status);
- if (U_FAILURE(status)) {
- log_err("Collator creation failed %s\n", testrules[i]);
- return;
+ U_ASSERT(expectedCount >= 0 && expectedCount < 31); /* [sic] 31 not 32 */
+ n = uenum_count(iter, &ec);
+ if (!assertSuccess("count", &ec)) return -1;
+ log_verbose("%s = [", msg);
+ for (;; ++i) {
+ const char* s = uenum_next(iter, NULL, &ec);
+ if (!assertSuccess("snext", &ec) || s == NULL) break;
+ if (i != 0) log_verbose(",");
+ log_verbose("%s", s);
+ /* check expected list */
+ for (j=0, bit=1; j<expectedCount; ++j, bit<<=1) {
+ if ((seenMask&bit) == 0 &&
+ uprv_strcmp(s, expected[j]) == 0) {
+ seenMask |= bit;
+ break;
+ }
}
-
- for (j = 0; j < 5; j ++) {
- doTest(coll, testdata[j], testdata[j + 1], UCOL_LESS);
+ }
+ log_verbose("] (%d)\n", i);
+ assertTrue("count verified", i==n);
+ /* did we see all expected strings? */
+ for (j=0, bit=1; j<expectedCount; ++j, bit<<=1) {
+ if ((seenMask&bit)!=0) {
+ log_verbose("Ok: \"%s\" seen\n", expected[j]);
+ } else {
+ log_err("FAIL: \"%s\" not seen\n", expected[j]);
}
- ucol_close(coll);
}
+ return n;
}
-#if 0
-/* this test tests the current limitations of the engine */
-/* it always fail, so it is disabled by default */
-static void TestLimitations(void) {
- /* recursive expansions */
- {
- static const char *rule = "&a=b/c&d=c/e";
- static const char *tlimit01[] = {"add","b","adf"};
- static const char *tlimit02[] = {"aa","b","af"};
- log_verbose("recursive expansions\n");
- genericRulesStarter(rule, tlimit01, sizeof(tlimit01)/sizeof(tlimit01[0]));
- genericRulesStarter(rule, tlimit02, sizeof(tlimit02)/sizeof(tlimit02[0]));
- }
- /* contractions spanning expansions */
- {
- static const char *rule = "&a<<<c/e&g<<<eh";
- static const char *tlimit01[] = {"ad","c","af","f","ch","h"};
- static const char *tlimit02[] = {"ad","c","ch","af","f","h"};
- log_verbose("contractions spanning expansions\n");
- genericRulesStarter(rule, tlimit01, sizeof(tlimit01)/sizeof(tlimit01[0]));
- genericRulesStarter(rule, tlimit02, sizeof(tlimit02)/sizeof(tlimit02[0]));
- }
- /* normalization: nulls in contractions */
- {
- static const char *rule = "&a<<<\\u0000\\u0302";
- static const char *tlimit01[] = {"a","\\u0000\\u0302\\u0327"};
- static const char *tlimit02[] = {"\\u0000\\u0302\\u0327","a"};
- static const UColAttribute att[] = { UCOL_DECOMPOSITION_MODE };
- static const UColAttributeValue valOn[] = { UCOL_ON };
- static const UColAttributeValue valOff[] = { UCOL_OFF };
+/**
+ * Test new API added for separate collation tree.
+ */
+static void TestSeparateTrees(void) {
+ UErrorCode ec = U_ZERO_ERROR;
+ UEnumeration *e = NULL;
+ int32_t n = -1;
+ UBool isAvailable;
+ char loc[256];
- log_verbose("NULL in contractions\n");
- genericRulesStarterWithOptions(rule, tlimit01, 2, att, valOn, 1);
- genericRulesStarterWithOptions(rule, tlimit02, 2, att, valOn, 1);
- genericRulesStarterWithOptions(rule, tlimit01, 2, att, valOff, 1);
- genericRulesStarterWithOptions(rule, tlimit02, 2, att, valOff, 1);
+ static const char* AVAIL[] = { "en", "de" };
- }
- /* normalization: contractions spanning normalization */
- {
- static const char *rule = "&a<<<\\u0000\\u0302";
- static const char *tlimit01[] = {"a","\\u0000\\u0302\\u0327"};
- static const char *tlimit02[] = {"\\u0000\\u0302\\u0327","a"};
- static const UColAttribute att[] = { UCOL_DECOMPOSITION_MODE };
- static const UColAttributeValue valOn[] = { UCOL_ON };
- static const UColAttributeValue valOff[] = { UCOL_OFF };
+ static const char* KW[] = { "collation" };
- log_verbose("contractions spanning normalization\n");
- genericRulesStarterWithOptions(rule, tlimit01, 2, att, valOn, 1);
- genericRulesStarterWithOptions(rule, tlimit02, 2, att, valOn, 1);
- genericRulesStarterWithOptions(rule, tlimit01, 2, att, valOff, 1);
- genericRulesStarterWithOptions(rule, tlimit02, 2, att, valOff, 1);
+ static const char* KWVAL[] = { "phonebook", "stroke" };
- }
- /* variable top: */
- {
- /*static const char *rule2 = "&\\u2010<x=[variable top]<z";*/
- static const char *rule = "&\\u2010<x<[variable top]=z";
- /*static const char *rule3 = "&' '<x<[variable top]=z";*/
- static const char *tlimit01[] = {" ", "z", "zb", "a", " b", "xb", "b", "c" };
- static const char *tlimit02[] = {"-", "-x", "x","xb", "-z", "z", "zb", "-a", "a", "-b", "b", "c"};
- static const char *tlimit03[] = {" ", "xb", "z", "zb", "a", " b", "b", "c" };
- static const UColAttribute att[] = { UCOL_ALTERNATE_HANDLING, UCOL_STRENGTH };
- static const UColAttributeValue valOn[] = { UCOL_SHIFTED, UCOL_QUATERNARY };
- static const UColAttributeValue valOff[] = { UCOL_NON_IGNORABLE, UCOL_TERTIARY };
+#if !UCONFIG_NO_SERVICE
+ e = ucol_openAvailableLocales(&ec);
+ if (e != NULL) {
+ assertSuccess("ucol_openAvailableLocales", &ec);
+ assertTrue("ucol_openAvailableLocales!=0", e!=0);
+ n = checkUEnumeration("ucol_openAvailableLocales", e, AVAIL, UPRV_LENGTHOF(AVAIL));
+ (void)n; /* Suppress set but not used warnings. */
+ /* Don't need to check n because we check list */
+ uenum_close(e);
+ } else {
+ log_data_err("Error calling ucol_openAvailableLocales() -> %s (Are you missing data?)\n", u_errorName(ec));
+ }
+#endif
- log_verbose("variable top\n");
- genericRulesStarterWithOptions(rule, tlimit03, sizeof(tlimit03)/sizeof(tlimit03[0]), att, valOn, sizeof(att)/sizeof(att[0]));
- genericRulesStarterWithOptions(rule, tlimit01, sizeof(tlimit01)/sizeof(tlimit01[0]), att, valOn, sizeof(att)/sizeof(att[0]));
- genericRulesStarterWithOptions(rule, tlimit02, sizeof(tlimit02)/sizeof(tlimit02[0]), att, valOn, sizeof(att)/sizeof(att[0]));
- genericRulesStarterWithOptions(rule, tlimit01, sizeof(tlimit01)/sizeof(tlimit01[0]), att, valOff, sizeof(att)/sizeof(att[0]));
- genericRulesStarterWithOptions(rule, tlimit02, sizeof(tlimit02)/sizeof(tlimit02[0]), att, valOff, sizeof(att)/sizeof(att[0]));
+ e = ucol_getKeywords(&ec);
+ if (e != NULL) {
+ assertSuccess("ucol_getKeywords", &ec);
+ assertTrue("ucol_getKeywords!=0", e!=0);
+ n = checkUEnumeration("ucol_getKeywords", e, KW, UPRV_LENGTHOF(KW));
+ /* Don't need to check n because we check list */
+ uenum_close(e);
+ } else {
+ log_data_err("Error calling ucol_getKeywords() -> %s (Are you missing data?)\n", u_errorName(ec));
+ }
- }
- /* case level */
- {
- static const char *rule = "&c<ch<<<cH<<<Ch<<<CH";
- static const char *tlimit01[] = {"c","CH","Ch","cH","ch"};
- static const char *tlimit02[] = {"c","CH","cH","Ch","ch"};
- static const UColAttribute att[] = { UCOL_CASE_FIRST};
- static const UColAttributeValue valOn[] = { UCOL_UPPER_FIRST};
- /*static const UColAttributeValue valOff[] = { UCOL_OFF};*/
- log_verbose("case level\n");
- genericRulesStarterWithOptions(rule, tlimit01, sizeof(tlimit01)/sizeof(tlimit01[0]), att, valOn, sizeof(att)/sizeof(att[0]));
- genericRulesStarterWithOptions(rule, tlimit02, sizeof(tlimit02)/sizeof(tlimit02[0]), att, valOn, sizeof(att)/sizeof(att[0]));
- /*genericRulesStarterWithOptions(rule, tlimit01, sizeof(tlimit01)/sizeof(tlimit01[0]), att, valOff, sizeof(att)/sizeof(att[0]));*/
- /*genericRulesStarterWithOptions(rule, tlimit02, sizeof(tlimit02)/sizeof(tlimit02[0]), att, valOff, sizeof(att)/sizeof(att[0]));*/
- }
+ e = ucol_getKeywordValues(KW[0], &ec);
+ if (e != NULL) {
+ assertSuccess("ucol_getKeywordValues", &ec);
+ assertTrue("ucol_getKeywordValues!=0", e!=0);
+ n = checkUEnumeration("ucol_getKeywordValues", e, KWVAL, UPRV_LENGTHOF(KWVAL));
+ /* Don't need to check n because we check list */
+ uenum_close(e);
+ } else {
+ log_data_err("Error calling ucol_getKeywordValues() -> %s (Are you missing data?)\n", u_errorName(ec));
+ }
+
+ /* Try setting a warning before calling ucol_getKeywordValues */
+ ec = U_USING_FALLBACK_WARNING;
+ e = ucol_getKeywordValues(KW[0], &ec);
+ if (assertSuccess("ucol_getKeywordValues [with warning code set]", &ec)) {
+ assertTrue("ucol_getKeywordValues!=0 [with warning code set]", e!=0);
+ n = checkUEnumeration("ucol_getKeywordValues [with warning code set]", e, KWVAL, UPRV_LENGTHOF(KWVAL));
+ /* Don't need to check n because we check list */
+ uenum_close(e);
+ }
+ /*
+U_DRAFT int32_t U_EXPORT2
+ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,
+ const char* locale, UBool* isAvailable,
+ UErrorCode* status);
}
-#endif
+*/
+ n = ucol_getFunctionalEquivalent(loc, sizeof(loc), "collation", "de",
+ &isAvailable, &ec);
+ if (assertSuccess("getFunctionalEquivalent", &ec)) {
+ assertEquals("getFunctionalEquivalent(de)", "root", loc);
+ assertTrue("getFunctionalEquivalent(de).isAvailable==TRUE",
+ isAvailable == TRUE);
+ }
-static void TestBocsuCoverage(void) {
- UErrorCode status = U_ZERO_ERROR;
- const char *testString = "\\u0041\\u0441\\u4441\\U00044441\\u4441\\u0441\\u0041";
- UChar test[256] = {0};
- uint32_t tlen = u_unescape(testString, test, 32);
- uint8_t key[256] = {0};
- uint32_t klen = 0;
+ n = ucol_getFunctionalEquivalent(loc, sizeof(loc), "collation", "de_DE",
+ &isAvailable, &ec);
+ if (assertSuccess("getFunctionalEquivalent", &ec)) {
+ assertEquals("getFunctionalEquivalent(de_DE)", "root", loc);
+ assertTrue("getFunctionalEquivalent(de_DE).isAvailable==FALSE",
+ isAvailable == FALSE);
+ }
+}
- UCollator *coll = ucol_open("", &status);
- if(U_SUCCESS(status)) {
- ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_IDENTICAL, &status);
+/* supercedes TestJ784 */
+static void TestBeforePinyin(void) {
+ const static char rules[] = {
+ "&[before 2]A<<\\u0101<<<\\u0100<<\\u00E1<<<\\u00C1<<\\u01CE<<<\\u01CD<<\\u00E0<<<\\u00C0"
+ "&[before 2]e<<\\u0113<<<\\u0112<<\\u00E9<<<\\u00C9<<\\u011B<<<\\u011A<<\\u00E8<<<\\u00C8"
+ "&[before 2]i<<\\u012B<<<\\u012A<<\\u00ED<<<\\u00CD<<\\u01D0<<<\\u01CF<<\\u00EC<<<\\u00CC"
+ "&[before 2]o<<\\u014D<<<\\u014C<<\\u00F3<<<\\u00D3<<\\u01D2<<<\\u01D1<<\\u00F2<<<\\u00D2"
+ "&[before 2]u<<\\u016B<<<\\u016A<<\\u00FA<<<\\u00DA<<\\u01D4<<<\\u01D3<<\\u00F9<<<\\u00D9"
+ "&U<<\\u01D6<<<\\u01D5<<\\u01D8<<<\\u01D7<<\\u01DA<<<\\u01D9<<\\u01DC<<<\\u01DB<<\\u00FC"
+ };
+
+ const static char *test[] = {
+ "l\\u0101",
+ "la",
+ "l\\u0101n",
+ "lan ",
+ "l\\u0113",
+ "le",
+ "l\\u0113n",
+ "len"
+ };
+
+ const static char *test2[] = {
+ "x\\u0101",
+ "x\\u0100",
+ "X\\u0101",
+ "X\\u0100",
+ "x\\u00E1",
+ "x\\u00C1",
+ "X\\u00E1",
+ "X\\u00C1",
+ "x\\u01CE",
+ "x\\u01CD",
+ "X\\u01CE",
+ "X\\u01CD",
+ "x\\u00E0",
+ "x\\u00C0",
+ "X\\u00E0",
+ "X\\u00C0",
+ "xa",
+ "xA",
+ "Xa",
+ "XA",
+ "x\\u0101x",
+ "x\\u0100x",
+ "x\\u00E1x",
+ "x\\u00C1x",
+ "x\\u01CEx",
+ "x\\u01CDx",
+ "x\\u00E0x",
+ "x\\u00C0x",
+ "xax",
+ "xAx"
+ };
- klen = ucol_getSortKey(coll, test, tlen, key, 256);
+ const static char *test3[] = { // rdar://53741390
+ "\\u85CF", // 藏 cáng
+ "\\u92BA", // 銺 zàng
+ "\\u85CF\\u6587", // 藏文 zàngwén
+ "\\u85CF\\u8BED", // 藏语 zàngyǔ
+ "\\u81D3", // 臓 zàng
+ };
- ucol_close(coll);
- } else {
- log_data_err("Couldn't open UCA\n");
- }
+ genericRulesStarter(rules, test, UPRV_LENGTHOF(test));
+ genericLocaleStarter("zh", test, UPRV_LENGTHOF(test));
+ genericRulesStarter(rules, test2, UPRV_LENGTHOF(test2));
+ genericLocaleStarter("zh", test2, UPRV_LENGTHOF(test2));
+ genericLocaleStarter("zh", test3, UPRV_LENGTHOF(test3));
}
-static void TestVariableTopSetting(void) {
- UErrorCode status = U_ZERO_ERROR;
- const UChar *current = NULL;
- uint32_t varTopOriginal = 0, varTop1, varTop2;
- UCollator *coll = ucol_open("", &status);
- if(U_SUCCESS(status)) {
+static void TestBeforeTightening(void) {
+ static const struct {
+ const char *rules;
+ UErrorCode expectedStatus;
+ } tests[] = {
+ { "&[before 1]a<x", U_ZERO_ERROR },
+ { "&[before 1]a<<x", U_INVALID_FORMAT_ERROR },
+ { "&[before 1]a<<<x", U_INVALID_FORMAT_ERROR },
+ { "&[before 1]a=x", U_INVALID_FORMAT_ERROR },
+ { "&[before 2]a<x",U_INVALID_FORMAT_ERROR },
+ { "&[before 2]a<<x",U_ZERO_ERROR },
+ { "&[before 2]a<<<x",U_INVALID_FORMAT_ERROR },
+ { "&[before 2]a=x",U_INVALID_FORMAT_ERROR },
+ { "&[before 3]a<x",U_INVALID_FORMAT_ERROR },
+ { "&[before 3]a<<x",U_INVALID_FORMAT_ERROR },
+ { "&[before 3]a<<<x",U_ZERO_ERROR },
+ { "&[before 3]a=x",U_INVALID_FORMAT_ERROR },
+ { "&[before I]a = x",U_INVALID_FORMAT_ERROR }
+ };
- uint32_t strength = 0;
- uint16_t specs = 0;
- uint32_t chOffset = 0;
- uint32_t chLen = 0;
- uint32_t exOffset = 0;
- uint32_t exLen = 0;
- uint32_t oldChOffset = 0;
- uint32_t oldChLen = 0;
- uint32_t oldExOffset = 0;
- uint32_t oldExLen = 0;
- uint32_t prefixOffset = 0;
- uint32_t prefixLen = 0;
-
- UBool startOfRules = TRUE;
- UColTokenParser src;
- UColOptionSet opts;
-
- UChar *rulesCopy = NULL;
- uint32_t rulesLen;
-
- UCollationResult result;
-
- UChar first[256] = { 0 };
- UChar second[256] = { 0 };
- UParseError parseError;
- int32_t myQ = QUICK;
-
- src.opts = &opts;
-
- if(QUICK <= 0) {
- QUICK = 1;
- }
+ int32_t i = 0;
- /* this test will fail when normalization is turned on */
- /* therefore we always turn off exhaustive mode for it */
- if(1) { /* QUICK > 0*/
- log_verbose("Slide variable top over UCARules\n");
- rulesLen = ucol_getRulesEx(coll, UCOL_FULL_RULES, rulesCopy, 0);
- rulesCopy = (UChar *)malloc((rulesLen+UCOL_TOK_EXTRA_RULE_SPACE_SIZE)*sizeof(UChar));
- rulesLen = ucol_getRulesEx(coll, UCOL_FULL_RULES, rulesCopy, rulesLen+UCOL_TOK_EXTRA_RULE_SPACE_SIZE);
-
- if(U_SUCCESS(status) && rulesLen > 0) {
- ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
- src.current = src.source = rulesCopy;
- src.end = rulesCopy+rulesLen;
- src.extraCurrent = src.end;
- src.extraEnd = src.end+UCOL_TOK_EXTRA_RULE_SPACE_SIZE;
-
- while ((current = ucol_tok_parseNextToken(&src, startOfRules, &parseError,&status)) != NULL) {
- strength = src.parsedToken.strength;
- chOffset = src.parsedToken.charsOffset;
- chLen = src.parsedToken.charsLen;
- exOffset = src.parsedToken.extensionOffset;
- exLen = src.parsedToken.extensionLen;
- prefixOffset = src.parsedToken.prefixOffset;
- prefixLen = src.parsedToken.prefixLen;
- specs = src.parsedToken.flags;
-
- startOfRules = FALSE;
- if(0) {
- log_verbose("%04X %d ", *(rulesCopy+chOffset), chLen);
- }
- if(strength == UCOL_PRIMARY) {
- status = U_ZERO_ERROR;
- varTopOriginal = ucol_getVariableTop(coll, &status);
- varTop1 = ucol_setVariableTop(coll, rulesCopy+oldChOffset, oldChLen, &status);
- if(U_FAILURE(status)) {
- char buffer[256];
- char *buf = buffer;
- uint32_t i = 0, j;
- uint32_t CE = UCOL_NO_MORE_CES;
-
- /* before we start screaming, let's see if there is a problem with the rules */
- collIterate s;
- uprv_init_collIterate(coll, rulesCopy+oldChOffset, oldChLen, &s);
-
- CE = ucol_getNextCE(coll, &s, &status);
-
- for(i = 0; i < oldChLen; i++) {
- j = sprintf(buf, "%04X ", *(rulesCopy+oldChOffset+i));
- buf += j;
- }
- if(status == U_PRIMARY_TOO_LONG_ERROR) {
- log_verbose("= Expected failure for %s =", buffer);
- } else {
- if(s.pos == s.endp) {
- log_err("Unexpected failure setting variable top at offset %d. Error %s. Codepoints: %s\n",
- oldChOffset, u_errorName(status), buffer);
- } else {
- log_verbose("There is a goofy contraction in UCA rules that does not appear in the fractional UCA. Codepoints: %s\n",
- buffer);
- }
- }
- }
- varTop2 = ucol_getVariableTop(coll, &status);
- if((varTop1 & 0xFFFF0000) != (varTop2 & 0xFFFF0000)) {
- log_err("cannot retrieve set varTop value!\n");
- continue;
- }
+ UErrorCode status = U_ZERO_ERROR;
+ UChar rlz[RULE_BUFFER_LEN] = { 0 };
+ uint32_t rlen = 0;
- if((varTop1 & 0xFFFF0000) > 0 && oldExLen == 0) {
-
- u_strncpy(first, rulesCopy+oldChOffset, oldChLen);
- u_strncpy(first+oldChLen, rulesCopy+chOffset, chLen);
- u_strncpy(first+oldChLen+chLen, rulesCopy+oldChOffset, oldChLen);
- first[2*oldChLen+chLen] = 0;
-
- if(oldExLen == 0) {
- u_strncpy(second, rulesCopy+chOffset, chLen);
- second[chLen] = 0;
- } else { /* This is skipped momentarily, but should work once UCARules are fully UCA conformant */
- u_strncpy(second, rulesCopy+oldExOffset, oldExLen);
- u_strncpy(second+oldChLen, rulesCopy+chOffset, chLen);
- u_strncpy(second+oldChLen+chLen, rulesCopy+oldExOffset, oldExLen);
- second[2*oldExLen+chLen] = 0;
- }
- result = ucol_strcoll(coll, first, -1, second, -1);
- if(result == UCOL_EQUAL) {
- doTest(coll, first, second, UCOL_EQUAL);
- } else {
- log_verbose("Suspicious strcoll result for %04X and %04X\n", *(rulesCopy+oldChOffset), *(rulesCopy+chOffset));
- }
- }
- }
- if(strength != UCOL_TOK_RESET) {
- oldChOffset = chOffset;
- oldChLen = chLen;
- oldExOffset = exOffset;
- oldExLen = exLen;
- }
- }
- status = U_ZERO_ERROR;
- }
- else {
- log_err("Unexpected failure getting rules %s\n", u_errorName(status));
- return;
- }
- if (U_FAILURE(status)) {
- log_err("Error parsing rules %s\n", u_errorName(status));
- return;
- }
- status = U_ZERO_ERROR;
- }
+ UCollator *coll = NULL;
- QUICK = myQ;
- log_verbose("Testing setting variable top to contractions\n");
- {
- /* uint32_t tailoredCE = UCOL_NOT_FOUND; */
- /*UChar *conts = (UChar *)((uint8_t *)coll->image + coll->image->UCAConsts+sizeof(UCAConstants));*/
- UChar *conts = (UChar *)((uint8_t *)coll->image + coll->image->contractionUCACombos);
- while(*conts != 0) {
- if(*(conts+2) == 0) {
- varTop1 = ucol_setVariableTop(coll, conts, -1, &status);
- } else {
- varTop1 = ucol_setVariableTop(coll, conts, 3, &status);
- }
- if(U_FAILURE(status)) {
- log_err("Couldn't set variable top to a contraction %04X %04X %04X\n",
- *conts, *(conts+1), *(conts+2));
+ for(i = 0; i < UPRV_LENGTHOF(tests); i++) {
+ rlen = u_unescape(tests[i].rules, rlz, RULE_BUFFER_LEN);
+ coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &status);
+ if(status != tests[i].expectedStatus) {
+ log_err_status(status, "Opening a collator with rules %s returned error code %s, expected %s\n",
+ tests[i].rules, u_errorName(status), u_errorName(tests[i].expectedStatus));
+ }
+ ucol_close(coll);
status = U_ZERO_ERROR;
- }
- conts+=3;
}
- status = U_ZERO_ERROR;
+}
- first[0] = 0x0040;
- first[1] = 0x0050;
- first[2] = 0x0000;
+/*
+&m < a
+&[before 1] a < x <<< X << q <<< Q < z
+assert: m <<< M < x <<< X << q <<< Q < z < a < n
- ucol_setVariableTop(coll, first, -1, &status);
+&m < a
+&[before 2] a << x <<< X << q <<< Q < z
+assert: m <<< M < x <<< X << q <<< Q << a < z < n
- if(U_SUCCESS(status)) {
- log_err("Invalid contraction succeded in setting variable top!\n");
- }
+&m < a
+&[before 3] a <<< x <<< X << q <<< Q < z
+assert: m <<< M < x <<< X <<< a << q <<< Q < z < n
- }
- log_verbose("Test restoring variable top\n");
+&m << a
+&[before 1] a < x <<< X << q <<< Q < z
+assert: x <<< X << q <<< Q < z < m <<< M << a < n
- status = U_ZERO_ERROR;
- ucol_restoreVariableTop(coll, varTopOriginal, &status);
- if(varTopOriginal != ucol_getVariableTop(coll, &status)) {
- log_err("Couldn't restore old variable top\n");
- }
+&m << a
+&[before 2] a << x <<< X << q <<< Q < z
+assert: m <<< M << x <<< X << q <<< Q << a < z < n
- log_verbose("Testing calling with error set\n");
+&m << a
+&[before 3] a <<< x <<< X << q <<< Q < z
+assert: m <<< M << x <<< X <<< a << q <<< Q < z < n
- status = U_INTERNAL_PROGRAM_ERROR;
- varTop1 = ucol_setVariableTop(coll, first, 1, &status);
- varTop2 = ucol_getVariableTop(coll, &status);
- ucol_restoreVariableTop(coll, varTop2, &status);
- varTop1 = ucol_setVariableTop(NULL, first, 1, &status);
- varTop2 = ucol_getVariableTop(NULL, &status);
- ucol_restoreVariableTop(NULL, varTop2, &status);
- if(status != U_INTERNAL_PROGRAM_ERROR) {
- log_err("Bad reaction to passed error!\n");
- }
- free(rulesCopy);
- ucol_close(coll);
- } else {
- log_data_err("Couldn't open UCA collator\n");
- }
-}
+&m <<< a
+&[before 1] a < x <<< X << q <<< Q < z
+assert: x <<< X << q <<< Q < z < n < m <<< a <<< M
-static void TestNonChars(void) {
- static const char *test[] = {
- "\\u0000",
- "\\uFFFE", "\\uFFFF",
- "\\U0001FFFE", "\\U0001FFFF",
- "\\U0002FFFE", "\\U0002FFFF",
- "\\U0003FFFE", "\\U0003FFFF",
- "\\U0004FFFE", "\\U0004FFFF",
- "\\U0005FFFE", "\\U0005FFFF",
- "\\U0006FFFE", "\\U0006FFFF",
- "\\U0007FFFE", "\\U0007FFFF",
- "\\U0008FFFE", "\\U0008FFFF",
- "\\U0009FFFE", "\\U0009FFFF",
- "\\U000AFFFE", "\\U000AFFFF",
- "\\U000BFFFE", "\\U000BFFFF",
- "\\U000CFFFE", "\\U000CFFFF",
- "\\U000DFFFE", "\\U000DFFFF",
- "\\U000EFFFE", "\\U000EFFFF",
- "\\U000FFFFE", "\\U000FFFFF",
- "\\U0010FFFE", "\\U0010FFFF"
- };
- UErrorCode status = U_ZERO_ERROR;
- UCollator *coll = ucol_open("en_US", &status);
+&m <<< a
+&[before 2] a << x <<< X << q <<< Q < z
+assert: x <<< X << q <<< Q << m <<< a <<< M < z < n
- log_verbose("Test non characters\n");
+&m <<< a
+&[before 3] a <<< x <<< X << q <<< Q < z
+assert: m <<< x <<< X <<< a <<< M << q <<< Q < z < n
- if(U_SUCCESS(status)) {
- genericOrderingTestWithResult(coll, test, 35, UCOL_EQUAL);
- } else {
- log_err("Unable to open collator\n");
- }
- ucol_close(coll);
-}
+&[before 1] s < x <<< X << q <<< Q < z
+assert: r <<< R < x <<< X << q <<< Q < z < s < n
-static void TestExtremeCompression(void) {
- static char *test[4];
- int32_t j = 0, i = 0;
+&[before 2] s << x <<< X << q <<< Q < z
+assert: r <<< R < x <<< X << q <<< Q << s < z < n
- for(i = 0; i<4; i++) {
- test[i] = (char *)malloc(2048*sizeof(char));
- }
+&[before 3] s <<< x <<< X << q <<< Q < z
+assert: r <<< R < x <<< X <<< s << q <<< Q < z < n
- for(j = 20; j < 500; j++) {
- for(i = 0; i<4; i++) {
- uprv_memset(test[i], 'a', (j-1)*sizeof(char));
- test[i][j-1] = (char)('a'+i);
- test[i][j] = 0;
- }
- genericLocaleStarter("en_US", (const char **)test, 4);
- }
+&[before 1] \u24DC < x <<< X << q <<< Q < z
+assert: x <<< X << q <<< Q < z < n < m <<< \u24DC <<< M
+
+&[before 2] \u24DC << x <<< X << q <<< Q < z
+assert: x <<< X << q <<< Q << m <<< \u24DC <<< M < z < n
+
+&[before 3] \u24DC <<< x <<< X << q <<< Q < z
+assert: m <<< x <<< X <<< \u24DC <<< M << q <<< Q < z < n
+*/
- for(i = 0; i<4; i++) {
- free(test[i]);
- }
-}
#if 0
-static void TestExtremeCompression(void) {
- static char *test[4];
- int32_t j = 0, i = 0;
- UErrorCode status = U_ZERO_ERROR;
- UCollator *coll = ucol_open("en_US", status);
- for(i = 0; i<4; i++) {
- test[i] = (char *)malloc(2048*sizeof(char));
- }
- for(j = 10; j < 2048; j++) {
- for(i = 0; i<4; i++) {
- uprv_memset(test[i], 'a', (j-2)*sizeof(char));
- test[i][j-1] = (char)('a'+i);
- test[i][j] = 0;
+/* requires features not yet supported */
+static void TestMoreBefore(void) {
+ static const struct {
+ const char* rules;
+ const char* order[16];
+ int32_t size;
+ } tests[] = {
+ { "&m < a &[before 1] a < x <<< X << q <<< Q < z",
+ { "m","M","x","X","q","Q","z","a","n" }, 9},
+ { "&m < a &[before 2] a << x <<< X << q <<< Q < z",
+ { "m","M","x","X","q","Q","a","z","n" }, 9},
+ { "&m < a &[before 3] a <<< x <<< X << q <<< Q < z",
+ { "m","M","x","X","a","q","Q","z","n" }, 9},
+ { "&m << a &[before 1] a < x <<< X << q <<< Q < z",
+ { "x","X","q","Q","z","m","M","a","n" }, 9},
+ { "&m << a &[before 2] a << x <<< X << q <<< Q < z",
+ { "m","M","x","X","q","Q","a","z","n" }, 9},
+ { "&m << a &[before 3] a <<< x <<< X << q <<< Q < z",
+ { "m","M","x","X","a","q","Q","z","n" }, 9},
+ { "&m <<< a &[before 1] a < x <<< X << q <<< Q < z",
+ { "x","X","q","Q","z","n","m","a","M" }, 9},
+ { "&m <<< a &[before 2] a << x <<< X << q <<< Q < z",
+ { "x","X","q","Q","m","a","M","z","n" }, 9},
+ { "&m <<< a &[before 3] a <<< x <<< X << q <<< Q < z",
+ { "m","x","X","a","M","q","Q","z","n" }, 9},
+ { "&[before 1] s < x <<< X << q <<< Q < z",
+ { "r","R","x","X","q","Q","z","s","n" }, 9},
+ { "&[before 2] s << x <<< X << q <<< Q < z",
+ { "r","R","x","X","q","Q","s","z","n" }, 9},
+ { "&[before 3] s <<< x <<< X << q <<< Q < z",
+ { "r","R","x","X","s","q","Q","z","n" }, 9},
+ { "&[before 1] \\u24DC < x <<< X << q <<< Q < z",
+ { "x","X","q","Q","z","n","m","\\u24DC","M" }, 9},
+ { "&[before 2] \\u24DC << x <<< X << q <<< Q < z",
+ { "x","X","q","Q","m","\\u24DC","M","z","n" }, 9},
+ { "&[before 3] \\u24DC <<< x <<< X << q <<< Q < z",
+ { "m","x","X","\\u24DC","M","q","Q","z","n" }, 9}
+ };
+
+ int32_t i = 0;
+
+ for(i = 0; i < UPRV_LENGTHOF(tests); i++) {
+ genericRulesStarter(tests[i].rules, tests[i].order, tests[i].size);
}
- }
- genericLocaleStarter("en_US", (const char **)test, 4);
+}
+#endif
+
+static void TestTailorNULL( void ) {
+ const static char* rule = "&a <<< '\\u0000'";
+ UErrorCode status = U_ZERO_ERROR;
+ UChar rlz[RULE_BUFFER_LEN] = { 0 };
+ uint32_t rlen = 0;
+ UChar a = 1, null = 0;
+ UCollationResult res = UCOL_EQUAL;
+
+ UCollator *coll = NULL;
+
+
+ rlen = u_unescape(rule, rlz, RULE_BUFFER_LEN);
+ coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &status);
+
+ if(U_FAILURE(status)) {
+ log_err_status(status, "Could not open default collator! -> %s\n", u_errorName(status));
+ } else {
+ res = ucol_strcoll(coll, &a, 1, &null, 1);
- for(j = 10; j < 2048; j++) {
- for(i = 0; i<1; i++) {
- uprv_memset(test[i], 'a', (j-1)*sizeof(char));
- test[i][j] = 0;
+ if(res != UCOL_LESS) {
+ log_err("NULL was not tailored properly!\n");
+ }
}
- }
- for(i = 0; i<4; i++) {
- free(test[i]);
- }
-}
-#endif
-
-static void TestSurrogates(void) {
- static const char *test[] = {
- "z","\\ud900\\udc25", "\\ud805\\udc50",
- "\\ud800\\udc00y", "\\ud800\\udc00r",
- "\\ud800\\udc00f", "\\ud800\\udc00",
- "\\ud800\\udc00c", "\\ud800\\udc00b",
- "\\ud800\\udc00fa", "\\ud800\\udc00fb",
- "\\ud800\\udc00a",
- "c", "b"
- };
- static const char *rule =
- "&z < \\ud900\\udc25 < \\ud805\\udc50"
- "< \\ud800\\udc00y < \\ud800\\udc00r"
- "< \\ud800\\udc00f << \\ud800\\udc00"
- "< \\ud800\\udc00fa << \\ud800\\udc00fb"
- "< \\ud800\\udc00a < c < b" ;
+ ucol_close(coll);
+}
- genericRulesStarter(rule, test, 14);
+static void
+TestUpperFirstQuaternary(void)
+{
+ const char* tests[] = { "B", "b", "Bb", "bB" };
+ UColAttribute att[] = { UCOL_STRENGTH, UCOL_CASE_FIRST };
+ UColAttributeValue attVals[] = { UCOL_QUATERNARY, UCOL_UPPER_FIRST };
+ genericLocaleStarterWithOptions("root", tests, UPRV_LENGTHOF(tests), att, attVals, UPRV_LENGTHOF(att));
}
-/* This is a test for prefix implementation, used by JIS X 4061 collation rules */
-static void TestPrefix(void) {
- uint32_t i;
+static void
+TestJ4960(void)
+{
+ const char* tests[] = { "\\u00e2T", "aT" };
+ UColAttribute att[] = { UCOL_STRENGTH, UCOL_CASE_LEVEL };
+ UColAttributeValue attVals[] = { UCOL_PRIMARY, UCOL_ON };
+ const char* tests2[] = { "a", "A" };
+ const char* rule = "&[first tertiary ignorable]=A=a";
+ UColAttribute att2[] = { UCOL_CASE_LEVEL };
+ UColAttributeValue attVals2[] = { UCOL_ON };
+ /* Test whether we correctly ignore primary ignorables on case level when */
+ /* we have only primary & case level */
+ genericLocaleStarterWithOptionsAndResult("root", tests, UPRV_LENGTHOF(tests), att, attVals, UPRV_LENGTHOF(att), UCOL_EQUAL);
+ /* Test whether ICU4J will make case level for sortkeys that have primary strength */
+ /* and case level */
+ genericLocaleStarterWithOptions("root", tests2, UPRV_LENGTHOF(tests2), att, attVals, UPRV_LENGTHOF(att));
+ /* Test whether completely ignorable letters have case level info (they shouldn't) */
+ genericRulesStarterWithOptionsAndResult(rule, tests2, UPRV_LENGTHOF(tests2), att2, attVals2, UPRV_LENGTHOF(att2), UCOL_EQUAL);
+}
- static struct {
- const char *rules;
- const char *data[50];
- const uint32_t len;
- } tests[] = {
- { "&z <<< z|a",
- {"zz", "za"}, 2 },
+static void
+TestJ5223(void)
+{
+ static const char *test = "this is a test string";
+ UChar ustr[256];
+ int32_t ustr_length = u_unescape(test, ustr, 256);
+ unsigned char sortkey[256];
+ int32_t sortkey_length;
+ UErrorCode status = U_ZERO_ERROR;
+ static UCollator *coll = NULL;
+ coll = ucol_open("root", &status);
+ if(U_FAILURE(status)) {
+ log_err_status(status, "Couldn't open UCA -> %s\n", u_errorName(status));
+ return;
+ }
+ ucol_setStrength(coll, UCOL_PRIMARY);
+ ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_PRIMARY, &status);
+ ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
+ if (U_FAILURE(status)) {
+ log_err("Failed setting atributes\n");
+ return;
+ }
+ sortkey_length = ucol_getSortKey(coll, ustr, ustr_length, NULL, 0);
+ if (sortkey_length > 256) return;
- { "&z <<< z| a",
- {"zz", "za"}, 2 },
- { "[strength I]"
- "&a=\\ud900\\udc25"
- "&z<<<\\ud900\\udc25|a",
- {"aa", "az", "\\ud900\\udc25z", "\\ud900\\udc25a", "zz"}, 4 },
- };
+ /* we mark the position where the null byte should be written in advance */
+ sortkey[sortkey_length-1] = 0xAA;
+ /* we set the buffer size one byte higher than needed */
+ sortkey_length = ucol_getSortKey(coll, ustr, ustr_length, sortkey,
+ sortkey_length+1);
- for(i = 0; i<(sizeof(tests)/sizeof(tests[0])); i++) {
- genericRulesStarter(tests[i].rules, tests[i].data, tests[i].len);
+ /* no error occurs (for me) */
+ if (sortkey[sortkey_length-1] == 0xAA) {
+ log_err("Hit bug at first try\n");
}
-}
-/* This test uses data suplied by Masashiko Maedera to test the implementation */
-/* JIS X 4061 collation order implementation */
-static void TestNewJapanese(void) {
+ /* we mark the position where the null byte should be written again */
+ sortkey[sortkey_length-1] = 0xAA;
- static const char *test1[] = {
- "\\u30b7\\u30e3\\u30fc\\u30ec",
- "\\u30b7\\u30e3\\u30a4",
- "\\u30b7\\u30e4\\u30a3",
- "\\u30b7\\u30e3\\u30ec",
- "\\u3061\\u3087\\u3053",
- "\\u3061\\u3088\\u3053",
- "\\u30c1\\u30e7\\u30b3\\u30ec\\u30fc\\u30c8",
- "\\u3066\\u30fc\\u305f",
- "\\u30c6\\u30fc\\u30bf",
- "\\u30c6\\u30a7\\u30bf",
- "\\u3066\\u3048\\u305f",
- "\\u3067\\u30fc\\u305f",
- "\\u30c7\\u30fc\\u30bf",
- "\\u30c7\\u30a7\\u30bf",
- "\\u3067\\u3048\\u305f",
- "\\u3066\\u30fc\\u305f\\u30fc",
- "\\u30c6\\u30fc\\u30bf\\u30a1",
- "\\u30c6\\u30a7\\u30bf\\u30fc",
- "\\u3066\\u3047\\u305f\\u3041",
- "\\u3066\\u3048\\u305f\\u30fc",
- "\\u3067\\u30fc\\u305f\\u30fc",
- "\\u30c7\\u30fc\\u30bf\\u30a1",
- "\\u3067\\u30a7\\u305f\\u30a1",
- "\\u30c7\\u3047\\u30bf\\u3041",
- "\\u30c7\\u30a8\\u30bf\\u30a2",
- "\\u3072\\u3086",
- "\\u3073\\u3085\\u3042",
- "\\u3074\\u3085\\u3042",
- "\\u3073\\u3085\\u3042\\u30fc",
- "\\u30d3\\u30e5\\u30a2\\u30fc",
- "\\u3074\\u3085\\u3042\\u30fc",
- "\\u30d4\\u30e5\\u30a2\\u30fc",
- "\\u30d2\\u30e5\\u30a6",
- "\\u30d2\\u30e6\\u30a6",
- "\\u30d4\\u30e5\\u30a6\\u30a2",
- "\\u3073\\u3085\\u30fc\\u3042\\u30fc",
- "\\u30d3\\u30e5\\u30fc\\u30a2\\u30fc",
- "\\u30d3\\u30e5\\u30a6\\u30a2\\u30fc",
- "\\u3072\\u3085\\u3093",
- "\\u3074\\u3085\\u3093",
- "\\u3075\\u30fc\\u308a",
- "\\u30d5\\u30fc\\u30ea",
- "\\u3075\\u3045\\u308a",
- "\\u3075\\u30a5\\u308a",
- "\\u3075\\u30a5\\u30ea",
- "\\u30d5\\u30a6\\u30ea",
- "\\u3076\\u30fc\\u308a",
- "\\u30d6\\u30fc\\u30ea",
- "\\u3076\\u3045\\u308a",
- "\\u30d6\\u30a5\\u308a",
- "\\u3077\\u3046\\u308a",
- "\\u30d7\\u30a6\\u30ea",
- "\\u3075\\u30fc\\u308a\\u30fc",
- "\\u30d5\\u30a5\\u30ea\\u30fc",
- "\\u3075\\u30a5\\u308a\\u30a3",
- "\\u30d5\\u3045\\u308a\\u3043",
- "\\u30d5\\u30a6\\u30ea\\u30fc",
- "\\u3075\\u3046\\u308a\\u3043",
- "\\u30d6\\u30a6\\u30ea\\u30a4",
- "\\u3077\\u30fc\\u308a\\u30fc",
- "\\u3077\\u30a5\\u308a\\u30a4",
- "\\u3077\\u3046\\u308a\\u30fc",
- "\\u30d7\\u30a6\\u30ea\\u30a4",
- "\\u30d5\\u30fd",
- "\\u3075\\u309e",
- "\\u3076\\u309d",
- "\\u3076\\u3075",
- "\\u3076\\u30d5",
- "\\u30d6\\u3075",
- "\\u30d6\\u30d5",
- "\\u3076\\u309e",
- "\\u3076\\u3077",
- "\\u30d6\\u3077",
- "\\u3077\\u309d",
- "\\u30d7\\u30fd",
- "\\u3077\\u3075",
-};
+ /* this time we set the buffer size to the exact amount needed */
+ sortkey_length = ucol_getSortKey(coll, ustr, ustr_length, sortkey,
+ sortkey_length);
- static const char *test2[] = {
- "\\u306f\\u309d", /* H\\u309d */
- /*"\\u30cf\\u30fd",*/ /* K\\u30fd */
- "\\u306f\\u306f", /* HH */
- "\\u306f\\u30cf", /* HK */
- "\\u30cf\\u30cf", /* KK */
- "\\u306f\\u309e", /* H\\u309e */
- "\\u30cf\\u30fe", /* K\\u30fe */
- "\\u306f\\u3070", /* HH\\u309b */
- "\\u30cf\\u30d0", /* KK\\u309b */
- "\\u306f\\u3071", /* HH\\u309c */
- "\\u30cf\\u3071", /* KH\\u309c */
- "\\u30cf\\u30d1", /* KK\\u309c */
- "\\u3070\\u309d", /* H\\u309b\\u309d */
- "\\u30d0\\u30fd", /* K\\u309b\\u30fd */
- "\\u3070\\u306f", /* H\\u309bH */
- "\\u30d0\\u30cf", /* K\\u309bK */
- "\\u3070\\u309e", /* H\\u309b\\u309e */
- "\\u30d0\\u30fe", /* K\\u309b\\u30fe */
- "\\u3070\\u3070", /* H\\u309bH\\u309b */
- "\\u30d0\\u3070", /* K\\u309bH\\u309b */
- "\\u30d0\\u30d0", /* K\\u309bK\\u309b */
- "\\u3070\\u3071", /* H\\u309bH\\u309c */
- "\\u30d0\\u30d1", /* K\\u309bK\\u309c */
- "\\u3071\\u309d", /* H\\u309c\\u309d */
- "\\u30d1\\u30fd", /* K\\u309c\\u30fd */
- "\\u3071\\u306f", /* H\\u309cH */
- "\\u30d1\\u30cf", /* K\\u309cK */
- "\\u3071\\u3070", /* H\\u309cH\\u309b */
- "\\u3071\\u30d0", /* H\\u309cK\\u309b */
- "\\u30d1\\u30d0", /* K\\u309cK\\u309b */
- "\\u3071\\u3071", /* H\\u309cH\\u309c */
- "\\u30d1\\u30d1", /* K\\u309cK\\u309c */
- };
- /*
- static const char *test3[] = {
- "\\u221er\\u221e",
- "\\u221eR#",
- "\\u221et\\u221e",
- "#r\\u221e",
- "#R#",
- "#t%",
- "#T%",
- "8t\\u221e",
- "8T\\u221e",
- "8t#",
- "8T#",
- "8t%",
- "8T%",
- "8t8",
- "8T8",
- "\\u03c9r\\u221e",
- "\\u03a9R%",
- "rr\\u221e",
- "rR\\u221e",
- "Rr\\u221e",
- "RR\\u221e",
- "RT%",
- "rt8",
- "tr\\u221e",
- "tr8",
- "TR8",
- "tt8",
- "\\u30b7\\u30e3\\u30fc\\u30ec",
- };
- */
- static const UColAttribute att[] = { UCOL_STRENGTH };
- static const UColAttributeValue val[] = { UCOL_QUATERNARY };
+ /* now the trailing null byte is not written */
+ if (sortkey[sortkey_length-1] == 0xAA) {
+ log_err("Hit bug at second try\n");
+ }
- static const UColAttribute attShifted[] = { UCOL_STRENGTH, UCOL_ALTERNATE_HANDLING};
- static const UColAttributeValue valShifted[] = { UCOL_QUATERNARY, UCOL_SHIFTED };
+ ucol_close(coll);
+}
+
+/* Regression test for Thai partial sort key problem */
+static void
+TestJ5232(void)
+{
+ const static char *test[] = {
+ "\\u0e40\\u0e01\\u0e47\\u0e1a\\u0e40\\u0e25\\u0e47\\u0e21",
+ "\\u0e40\\u0e01\\u0e47\\u0e1a\\u0e40\\u0e25\\u0e48\\u0e21"
+ };
- genericLocaleStarterWithOptions("ja", test1, sizeof(test1)/sizeof(test1[0]), att, val, 1);
- genericLocaleStarterWithOptions("ja", test2, sizeof(test2)/sizeof(test2[0]), att, val, 1);
- /*genericLocaleStarter("ja", test3, sizeof(test3)/sizeof(test3[0]));*/
- genericLocaleStarterWithOptions("ja", test1, sizeof(test1)/sizeof(test1[0]), attShifted, valShifted, 2);
- genericLocaleStarterWithOptions("ja", test2, sizeof(test2)/sizeof(test2[0]), attShifted, valShifted, 2);
+ genericLocaleStarter("th", test, UPRV_LENGTHOF(test));
}
-static void TestStrCollIdenticalPrefix(void) {
- const char* rule = "&\\ud9b0\\udc70=\\ud9b0\\udc71";
- const char* test[] = {
- "ab\\ud9b0\\udc70",
- "ab\\ud9b0\\udc71"
- };
- genericRulesTestWithResult(rule, test, sizeof(test)/sizeof(test[0]), UCOL_EQUAL);
+static void
+TestJ5367(void)
+{
+ const static char *test[] = { "a", "y" };
+ const char* rules = "&Ny << Y &[first secondary ignorable] <<< a";
+ genericRulesStarter(rules, test, UPRV_LENGTHOF(test));
}
-/* Contractions should have all their canonically equivalent */
-/* strings included */
-static void TestContractionClosure(void) {
- static struct {
- const char *rules;
- const char *data[50];
- const uint32_t len;
- } tests[] = {
- { "&b=\\u00e4\\u00e4",
- { "b", "\\u00e4\\u00e4", "a\\u0308a\\u0308", "\\u00e4a\\u0308", "a\\u0308\\u00e4" }, 5},
- { "&b=\\u00C5",
- { "b", "\\u00C5", "A\\u030A", "\\u212B" }, 4},
- };
- uint32_t i;
+static void
+TestVI5913(void)
+{
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t i, j;
+ UCollator *coll =NULL;
+ uint8_t resColl[100], expColl[100];
+ int32_t rLen, tLen, ruleLen, sLen, kLen;
+ UChar rule[256]={0x26, 0x62, 0x3c, 0x1FF3, 0}; /* &b<0x1FF3-omega with Ypogegrammeni*/
+ UChar rule2[256]={0x26, 0x7a, 0x3c, 0x0161, 0}; /* &z<s with caron*/
+ /*
+ * Note: Just tailoring &z<ae^ does not work as expected:
+ * The UCA spec requires for discontiguous contractions that they
+ * extend an *existing match* by one combining mark at a time.
+ * Therefore, ae must be a contraction so that the builder finds
+ * discontiguous contractions for ae^, for example with an intervening underdot.
+ * Only then do we get the expected tail closure with a\u1EC7, a\u1EB9\u0302, etc.
+ */
+ UChar rule3[256]={
+ 0x26, 0x78, 0x3c, 0x61, 0x65, /* &x<ae */
+ 0x26, 0x7a, 0x3c, 0x0061, 0x00ea, /* &z<a+e with circumflex.*/
+ 0};
+ static const UChar tData[][20]={
+ {0x1EAC, 0},
+ {0x0041, 0x0323, 0x0302, 0},
+ {0x1EA0, 0x0302, 0},
+ {0x00C2, 0x0323, 0},
+ {0x1ED8, 0}, /* O with dot and circumflex */
+ {0x1ECC, 0x0302, 0},
+ {0x1EB7, 0},
+ {0x1EA1, 0x0306, 0},
+ };
+ static const UChar tailorData[][20]={
+ {0x1FA2, 0}, /* Omega with 3 combining marks */
+ {0x03C9, 0x0313, 0x0300, 0x0345, 0},
+ {0x1FF3, 0x0313, 0x0300, 0},
+ {0x1F60, 0x0300, 0x0345, 0},
+ {0x1F62, 0x0345, 0},
+ {0x1FA0, 0x0300, 0},
+ };
+ static const UChar tailorData2[][20]={
+ {0x1E63, 0x030C, 0}, /* s with dot below + caron */
+ {0x0073, 0x0323, 0x030C, 0},
+ {0x0073, 0x030C, 0x0323, 0},
+ };
+ static const UChar tailorData3[][20]={
+ {0x007a, 0}, /* z */
+ {0x0061, 0x0065, 0}, /* a + e */
+ {0x0061, 0x00ea, 0}, /* a + e with circumflex */
+ {0x0061, 0x1EC7, 0}, /* a+ e with dot below and circumflex */
+ {0x0061, 0x1EB9, 0x0302, 0}, /* a + e with dot below + combining circumflex */
+ {0x0061, 0x00EA, 0x0323, 0}, /* a + e with circumflex + combining dot below */
+ {0x00EA, 0x0323, 0}, /* e with circumflex + combining dot below */
+ {0x00EA, 0}, /* e with circumflex */
+ };
+
+ /* Test Vietnamese sort. */
+ coll = ucol_open("vi", &status);
+ if(U_FAILURE(status)) {
+ log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status));
+ return;
+ }
+ log_verbose("\n\nVI collation:");
+ if ( !ucol_equal(coll, tData[0], u_strlen(tData[0]), tData[2], u_strlen(tData[2])) ) {
+ log_err("\\u1EAC not equals to \\u1EA0+\\u0302\n");
+ }
+ if ( !ucol_equal(coll, tData[0], u_strlen(tData[0]), tData[3], u_strlen(tData[3])) ) {
+ log_err("\\u1EAC not equals to \\u00c2+\\u0323\n");
+ }
+ if ( !ucol_equal(coll, tData[5], u_strlen(tData[5]), tData[4], u_strlen(tData[4])) ) {
+ log_err("\\u1ED8 not equals to \\u1ECC+\\u0302\n");
+ }
+ if ( !ucol_equal(coll, tData[7], u_strlen(tData[7]), tData[6], u_strlen(tData[6])) ) {
+ log_err("\\u1EB7 not equals to \\u1EA1+\\u0306\n");
+ }
+
+ for (j=0; j<8; j++) {
+ tLen = u_strlen(tData[j]);
+ log_verbose("\n Data :%s \tlen: %d key: ", tData[j], tLen);
+ rLen = ucol_getSortKey(coll, tData[j], tLen, resColl, 100);
+ for(i = 0; i<rLen; i++) {
+ log_verbose(" %02X", resColl[i]);
+ }
+ }
+
+ ucol_close(coll);
- for(i = 0; i<(sizeof(tests)/sizeof(tests[0])); i++) {
- genericRulesTestWithResult(tests[i].rules, tests[i].data, tests[i].len, UCOL_EQUAL);
- }
-}
+ /* Test Romanian sort. */
+ coll = ucol_open("ro", &status);
+ log_verbose("\n\nRO collation:");
+ if ( !ucol_equal(coll, tData[0], u_strlen(tData[0]), tData[1], u_strlen(tData[1])) ) {
+ log_err("\\u1EAC not equals to \\u1EA0+\\u0302\n");
+ }
+ if ( !ucol_equal(coll, tData[4], u_strlen(tData[4]), tData[5], u_strlen(tData[5])) ) {
+ log_err("\\u1EAC not equals to \\u00c2+\\u0323\n");
+ }
+ if ( !ucol_equal(coll, tData[6], u_strlen(tData[6]), tData[7], u_strlen(tData[7])) ) {
+ log_err("\\u1EB7 not equals to \\u1EA1+\\u0306\n");
+ }
-/* This tests also fails*/
-static void TestBeforePrefixFailure(void) {
- static struct {
- const char *rules;
- const char *data[50];
- const uint32_t len;
- } tests[] = {
- { "&g <<< a"
- "&[before 3]\\uff41 <<< x",
- {"x", "\\uff41"}, 2 },
- { "&\\u30A7=\\u30A7=\\u3047=\\uff6a"
- "&\\u30A8=\\u30A8=\\u3048=\\uff74"
- "&[before 3]\\u30a7<<<\\u30a9",
- {"\\u30a9", "\\u30a7"}, 2 },
- { "&[before 3]\\u30a7<<<\\u30a9"
- "&\\u30A7=\\u30A7=\\u3047=\\uff6a"
- "&\\u30A8=\\u30A8=\\u3048=\\uff74",
- {"\\u30a9", "\\u30a7"}, 2 },
- };
- uint32_t i;
+ for (j=4; j<8; j++) {
+ tLen = u_strlen(tData[j]);
+ log_verbose("\n Data :%s \tlen: %d key: ", tData[j], tLen);
+ rLen = ucol_getSortKey(coll, tData[j], tLen, resColl, 100);
+ for(i = 0; i<rLen; i++) {
+ log_verbose(" %02X", resColl[i]);
+ }
+ }
+ ucol_close(coll);
+ /* Test the precomposed Greek character with 3 combining marks. */
+ log_verbose("\n\nTailoring test: Greek character with 3 combining marks");
+ ruleLen = u_strlen(rule);
+ coll = ucol_openRules(rule, ruleLen, UCOL_OFF, UCOL_TERTIARY, NULL,&status);
+ if (U_FAILURE(status)) {
+ log_err("ucol_openRules failed with %s\n", u_errorName(status));
+ return;
+ }
+ sLen = u_strlen(tailorData[0]);
+ for (j=1; j<6; j++) {
+ tLen = u_strlen(tailorData[j]);
+ if ( !ucol_equal(coll, tailorData[0], sLen, tailorData[j], tLen)) {
+ log_err("\n \\u1FA2 not equals to data[%d]:%s\n", j, tailorData[j]);
+ }
+ }
+ /* Test getSortKey. */
+ tLen = u_strlen(tailorData[0]);
+ kLen=ucol_getSortKey(coll, tailorData[0], tLen, expColl, 100);
+ for (j=0; j<6; j++) {
+ tLen = u_strlen(tailorData[j]);
+ rLen = ucol_getSortKey(coll, tailorData[j], tLen, resColl, 100);
+ if ( kLen!=rLen || uprv_memcmp(expColl, resColl, rLen*sizeof(uint8_t))!=0 ) {
+ log_err("\n Data[%d] :%s \tlen: %d key: ", j, tailorData[j], tLen);
+ for(i = 0; i<rLen; i++) {
+ log_err(" %02X", resColl[i]);
+ }
+ }
+ }
+ ucol_close(coll);
- for(i = 0; i<(sizeof(tests)/sizeof(tests[0])); i++) {
- genericRulesStarter(tests[i].rules, tests[i].data, tests[i].len);
- }
+ log_verbose("\n\nTailoring test for s with caron:");
+ ruleLen = u_strlen(rule2);
+ coll = ucol_openRules(rule2, ruleLen, UCOL_OFF, UCOL_TERTIARY, NULL,&status);
+ tLen = u_strlen(tailorData2[0]);
+ kLen=ucol_getSortKey(coll, tailorData2[0], tLen, expColl, 100);
+ for (j=1; j<3; j++) {
+ tLen = u_strlen(tailorData2[j]);
+ rLen = ucol_getSortKey(coll, tailorData2[j], tLen, resColl, 100);
+ if ( kLen!=rLen || uprv_memcmp(expColl, resColl, rLen*sizeof(uint8_t))!=0 ) {
+ log_err("\n After tailoring Data[%d] :%s \tlen: %d key: ", j, tailorData[j], tLen);
+ for(i = 0; i<rLen; i++) {
+ log_err(" %02X", resColl[i]);
+ }
+ }
+ }
+ ucol_close(coll);
-#if 0
- const char* rule1 =
- "&\\u30A7=\\u30A7=\\u3047=\\uff6a"
- "&\\u30A8=\\u30A8=\\u3048=\\uff74"
- "&[before 3]\\u30a7<<<\\u30c6|\\u30fc";
- const char* rule2 =
- "&[before 3]\\u30a7<<<\\u30c6|\\u30fc"
- "&\\u30A7=\\u30A7=\\u3047=\\uff6a"
- "&\\u30A8=\\u30A8=\\u3048=\\uff74";
- const char* test[] = {
- "\\u30c6\\u30fc\\u30bf",
- "\\u30c6\\u30a7\\u30bf",
- };
- genericRulesStarter(rule1, test, sizeof(test)/sizeof(test[0]));
- genericRulesStarter(rule2, test, sizeof(test)/sizeof(test[0]));
-/* this piece of code should be in some sort of verbose mode */
-/* it gets the collation elements for elements and prints them */
-/* This is useful when trying to see whether the problem is */
- {
+ log_verbose("\n\nTailoring test for &z< ae with circumflex:");
+ ruleLen = u_strlen(rule3);
+ coll = ucol_openRules(rule3, ruleLen, UCOL_OFF, UCOL_TERTIARY, NULL,&status);
+ tLen = u_strlen(tailorData3[3]);
+ kLen=ucol_getSortKey(coll, tailorData3[3], tLen, expColl, 100);
+ log_verbose("\n Test Data[3] :%s \tlen: %d key: ", aescstrdup(tailorData3[3], tLen), tLen);
+ for(i = 0; i<kLen; i++) {
+ log_verbose(" %02X", expColl[i]);
+ }
+ for (j=4; j<6; j++) {
+ tLen = u_strlen(tailorData3[j]);
+ rLen = ucol_getSortKey(coll, tailorData3[j], tLen, resColl, 100);
+
+ if ( kLen!=rLen || uprv_memcmp(expColl, resColl, rLen*sizeof(uint8_t))!=0 ) {
+ log_err("\n After tailoring Data[%d] :%s \tlen: %d key: ", j, aescstrdup(tailorData3[j], tLen), tLen);
+ for(i = 0; i<rLen; i++) {
+ log_err(" %02X", resColl[i]);
+ }
+ }
+
+ log_verbose("\n Test Data[%d] :%s \tlen: %d key: ", j, aescstrdup(tailorData3[j], tLen), tLen);
+ for(i = 0; i<rLen; i++) {
+ log_verbose(" %02X", resColl[i]);
+ }
+ }
+ ucol_close(coll);
+}
+
+static void
+TestTailor6179(void)
+{
UErrorCode status = U_ZERO_ERROR;
- uint32_t i = 0;
- UCollationElements *it = NULL;
- uint32_t CE;
- UChar string[256];
- uint32_t uStringLen;
- UCollator *coll = NULL;
+ int32_t i;
+ UCollator *coll =NULL;
+ uint8_t resColl[100];
+ int32_t rLen, tLen, ruleLen;
+ /* &[last primary ignorable]<< a &[first primary ignorable]<<b */
+ static const UChar rule1[]={
+ 0x26,0x5B,0x6C,0x61,0x73,0x74,0x20,0x70,0x72,0x69,0x6D,0x61,0x72,0x79,
+ 0x20,0x69,0x67,0x6E,0x6F,0x72,0x61,0x62,0x6C,0x65,0x5D,0x3C,0x3C,0x20,0x61,0x20,
+ 0x26,0x5B,0x66,0x69,0x72,0x73,0x74,0x20,0x70,0x72,0x69,0x6D,0x61,0x72,0x79,0x20,
+ 0x69,0x67,0x6E,0x6F,0x72,0x61,0x62,0x6C,0x65,0x5D,0x3C,0x3C,0x62,0x20, 0};
+ /* &[last secondary ignorable]<<< a &[first secondary ignorable]<<<b */
+ static const UChar rule2[]={
+ 0x26,0x5B,0x6C,0x61,0x73,0x74,0x20,0x73,0x65,0x63,0x6F,0x6E,0x64,0x61,
+ 0x72,0x79,0x20,0x69,0x67,0x6E,0x6F,0x72,0x61,0x62,0x6C,0x65,0x5D,0x3C,0x3C,0x3C,
+ 0x61,0x20,0x26,0x5B,0x66,0x69,0x72,0x73,0x74,0x20,0x73,0x65,0x63,0x6F,0x6E,
+ 0x64,0x61,0x72,0x79,0x20,0x69,0x67,0x6E,0x6F,0x72,0x61,0x62,0x6C,0x65,0x5D,0x3C,
+ 0x3C,0x3C,0x20,0x62,0};
+
+ static const UChar tData1[][4]={
+ {0x61, 0},
+ {0x62, 0},
+ { 0xFDD0,0x009E, 0}
+ };
+ static const UChar tData2[][4]={
+ {0x61, 0},
+ {0x62, 0},
+ { 0xFDD0,0x009E, 0}
+ };
- uStringLen = u_unescape(rule1, string, 256);
+ /*
+ * These values from FractionalUCA.txt will change,
+ * and need to be updated here.
+ * TODO: Make this not check for particular sort keys.
+ * Instead, test that we get CEs before & after other ignorables; see ticket #6179.
+ */
+ static const uint8_t firstPrimaryIgnCE[]={1, 0x83, 1, 5, 0};
+ static const uint8_t lastPrimaryIgnCE[]={1, 0xFC, 1, 5, 0};
+ static const uint8_t firstSecondaryIgnCE[]={1, 1, 0xfe, 0};
+ static const uint8_t lastSecondaryIgnCE[]={1, 1, 0xff, 0};
- coll = ucol_openRules(string, uStringLen, UCOL_DEFAULT, UCOL_DEFAULT, NULL, &status);
+ UParseError parseError;
- /*coll = ucol_open("ja_JP_JIS", &status);*/
- it = ucol_openElements(coll, string, 0, &status);
+ /* Test [Last Primary ignorable] */
- for(i = 0; i < sizeof(test)/sizeof(test[0]); i++) {
- log_verbose("%s\n", test[i]);
- uStringLen = u_unescape(test[i], string, 256);
- ucol_setText(it, string, uStringLen, &status);
+ log_verbose("Tailoring test: &[last primary ignorable]<<a &[first primary ignorable]<<b\n");
+ ruleLen = u_strlen(rule1);
+ coll = ucol_openRules(rule1, ruleLen, UCOL_OFF, UCOL_TERTIARY, NULL,&status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "Tailoring test: &[last primary ignorable] failed! -> %s\n", u_errorName(status));
+ return;
+ }
+ tLen = u_strlen(tData1[0]);
+ rLen = ucol_getSortKey(coll, tData1[0], tLen, resColl, 100);
+ if (rLen != UPRV_LENGTHOF(lastPrimaryIgnCE) || uprv_memcmp(resColl, lastPrimaryIgnCE, rLen) != 0) {
+ log_err("Bad result for &[lpi]<<a...: Data[%d] :%s \tlen: %d key: ", 0, tData1[0], rLen);
+ for(i = 0; i<rLen; i++) {
+ log_err(" %02X", resColl[i]);
+ }
+ log_err("\n");
+ }
+ tLen = u_strlen(tData1[1]);
+ rLen = ucol_getSortKey(coll, tData1[1], tLen, resColl, 100);
+ if (rLen != UPRV_LENGTHOF(firstPrimaryIgnCE) || uprv_memcmp(resColl, firstPrimaryIgnCE, rLen) != 0) {
+ log_err("Bad result for &[lpi]<<a...: Data[%d] :%s \tlen: %d key: ", 1, tData1[1], rLen);
+ for(i = 0; i<rLen; i++) {
+ log_err(" %02X", resColl[i]);
+ }
+ log_err("\n");
+ }
+ ucol_close(coll);
- while((CE=ucol_next(it, &status)) != UCOL_NULLORDER) {
- log_verbose("%08X\n", CE);
+
+ /* Test [Last Secondary ignorable] */
+ log_verbose("Tailoring test: &[last secondary ignorable]<<<a &[first secondary ignorable]<<<b\n");
+ ruleLen = u_strlen(rule2);
+ coll = ucol_openRules(rule2, ruleLen, UCOL_OFF, UCOL_TERTIARY, &parseError, &status);
+ if (U_FAILURE(status)) {
+ log_err("Tailoring test: &[last secondary ignorable] failed! -> %s\n", u_errorName(status));
+ log_info(" offset=%d \"%s\" | \"%s\"\n",
+ parseError.offset, aescstrdup(parseError.preContext, -1), aescstrdup(parseError.postContext, -1));
+ return;
+ }
+ tLen = u_strlen(tData2[0]);
+ rLen = ucol_getSortKey(coll, tData2[0], tLen, resColl, 100);
+ if (rLen != UPRV_LENGTHOF(lastSecondaryIgnCE) || uprv_memcmp(resColl, lastSecondaryIgnCE, rLen) != 0) {
+ log_err("Bad result for &[lsi]<<<a...: Data[%d] :%s \tlen: %d key: ", 0, tData2[0], rLen);
+ for(i = 0; i<rLen; i++) {
+ log_err(" %02X", resColl[i]);
+ }
+ log_err("\n");
+ }
+ tLen = u_strlen(tData2[1]);
+ rLen = ucol_getSortKey(coll, tData2[1], tLen, resColl, 100);
+ if (rLen != UPRV_LENGTHOF(firstSecondaryIgnCE) || uprv_memcmp(resColl, firstSecondaryIgnCE, rLen) != 0) {
+ log_err("Bad result for &[lsi]<<<a...: Data[%d] :%s \tlen: %d key: ", 1, tData2[1], rLen);
+ for(i = 0; i<rLen; i++) {
+ log_err(" %02X", resColl[i]);
}
- log_verbose("\n");
+ log_err("\n");
+ }
+ ucol_close(coll);
+}
+static void
+TestUCAPrecontext(void)
+{
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t i, j;
+ UCollator *coll =NULL;
+ uint8_t resColl[100], prevColl[100];
+ int32_t rLen, tLen, ruleLen;
+ UChar rule1[256]= {0x26, 0xb7, 0x3c, 0x61, 0}; /* & middle-dot < a */
+ UChar rule2[256]= {0x26, 0x4C, 0xb7, 0x3c, 0x3c, 0x61, 0};
+ /* & l middle-dot << a a is an expansion. */
+
+ UChar tData1[][20]={
+ { 0xb7, 0}, /* standalone middle dot(0xb7) */
+ { 0x387, 0}, /* standalone middle dot(0x387) */
+ { 0x61, 0}, /* a */
+ { 0x6C, 0}, /* l */
+ { 0x4C, 0x0332, 0}, /* l with [first primary ignorable] */
+ { 0x6C, 0xb7, 0}, /* l with middle dot(0xb7) */
+ { 0x6C, 0x387, 0}, /* l with middle dot(0x387) */
+ { 0x4C, 0xb7, 0}, /* L with middle dot(0xb7) */
+ { 0x4C, 0x387, 0}, /* L with middle dot(0x387) */
+ { 0x6C, 0x61, 0x387, 0}, /* la with middle dot(0x387) */
+ { 0x4C, 0x61, 0xb7, 0}, /* La with middle dot(0xb7) */
+ };
+
+ log_verbose("\n\nEN collation:");
+ coll = ucol_open("en", &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "Tailoring test: &z <<a|- failed! -> %s\n", u_errorName(status));
+ return;
}
+ for (j=0; j<11; j++) {
+ tLen = u_strlen(tData1[j]);
+ rLen = ucol_getSortKey(coll, tData1[j], tLen, resColl, 100);
+ if ((j>0) && (strcmp((char *)resColl, (char *)prevColl)<0)) {
+ log_err("\n Expecting greater key than previous test case: Data[%d] :%s.",
+ j, tData1[j]);
+ }
+ log_verbose("\n Data[%d] :%s \tlen: %d key: ", j, tData1[j], rLen);
+ for(i = 0; i<rLen; i++) {
+ log_verbose(" %02X", resColl[i]);
+ }
+ uprv_memcpy(prevColl, resColl, sizeof(uint8_t)*(rLen+1));
+ }
+ ucol_close(coll);
+
+
+ log_verbose("\n\nJA collation:");
+ coll = ucol_open("ja", &status);
+ if (U_FAILURE(status)) {
+ log_err("Tailoring test: &z <<a|- failed!");
+ return;
+ }
+ for (j=0; j<11; j++) {
+ tLen = u_strlen(tData1[j]);
+ rLen = ucol_getSortKey(coll, tData1[j], tLen, resColl, 100);
+ if ((j>0) && (strcmp((char *)resColl, (char *)prevColl)<0)) {
+ log_err("\n Expecting greater key than previous test case: Data[%d] :%s.",
+ j, tData1[j]);
+ }
+ log_verbose("\n Data[%d] :%s \tlen: %d key: ", j, tData1[j], rLen);
+ for(i = 0; i<rLen; i++) {
+ log_verbose(" %02X", resColl[i]);
+ }
+ uprv_memcpy(prevColl, resColl, sizeof(uint8_t)*(rLen+1));
+ }
+ ucol_close(coll);
- ucol_closeElements(it);
- ucol_close(coll);
- }
-#endif
+
+ log_verbose("\n\nTailoring test: & middle dot < a ");
+ ruleLen = u_strlen(rule1);
+ coll = ucol_openRules(rule1, ruleLen, UCOL_OFF, UCOL_TERTIARY, NULL,&status);
+ if (U_FAILURE(status)) {
+ log_err("Tailoring test: & middle dot < a failed!");
+ return;
+ }
+ for (j=0; j<11; j++) {
+ tLen = u_strlen(tData1[j]);
+ rLen = ucol_getSortKey(coll, tData1[j], tLen, resColl, 100);
+ if ((j>0) && (strcmp((char *)resColl, (char *)prevColl)<0)) {
+ log_err("\n Expecting greater key than previous test case: Data[%d] :%s.",
+ j, tData1[j]);
+ }
+ log_verbose("\n Data[%d] :%s \tlen: %d key: ", j, tData1[j], rLen);
+ for(i = 0; i<rLen; i++) {
+ log_verbose(" %02X", resColl[i]);
+ }
+ uprv_memcpy(prevColl, resColl, sizeof(uint8_t)*(rLen+1));
+ }
+ ucol_close(coll);
+
+
+ log_verbose("\n\nTailoring test: & l middle-dot << a ");
+ ruleLen = u_strlen(rule2);
+ coll = ucol_openRules(rule2, ruleLen, UCOL_OFF, UCOL_TERTIARY, NULL,&status);
+ if (U_FAILURE(status)) {
+ log_err("Tailoring test: & l middle-dot << a failed!");
+ return;
+ }
+ for (j=0; j<11; j++) {
+ tLen = u_strlen(tData1[j]);
+ rLen = ucol_getSortKey(coll, tData1[j], tLen, resColl, 100);
+ if ((j>0) && (j!=3) && (strcmp((char *)resColl, (char *)prevColl)<0)) {
+ log_err("\n Expecting greater key than previous test case: Data[%d] :%s.",
+ j, tData1[j]);
+ }
+ if ((j==3)&&(strcmp((char *)resColl, (char *)prevColl)>0)) {
+ log_err("\n Expecting smaller key than previous test case: Data[%d] :%s.",
+ j, tData1[j]);
+ }
+ log_verbose("\n Data[%d] :%s \tlen: %d key: ", j, tData1[j], rLen);
+ for(i = 0; i<rLen; i++) {
+ log_verbose(" %02X", resColl[i]);
+ }
+ uprv_memcpy(prevColl, resColl, sizeof(uint8_t)*(rLen+1));
+ }
+ ucol_close(coll);
}
-static void TestPrefixCompose(void) {
- const char* rule1 =
- "&\\u30a7<<<\\u30ab|\\u30fc=\\u30ac|\\u30fc";
- /*
- const char* test[] = {
- "\\u30c6\\u30fc\\u30bf",
- "\\u30c6\\u30a7\\u30bf",
- };
- */
- {
+static void
+TestOutOfBuffer5468(void)
+{
+ static const char *test = "\\u4e00";
+ UChar ustr[256];
+ int32_t ustr_length = u_unescape(test, ustr, 256);
+ unsigned char shortKeyBuf[1];
+ int32_t sortkey_length;
UErrorCode status = U_ZERO_ERROR;
- /*uint32_t i = 0;*/
- /*UCollationElements *it = NULL;*/
-/* uint32_t CE;*/
- UChar string[256];
- uint32_t uStringLen;
- UCollator *coll = NULL;
+ static UCollator *coll = NULL;
- uStringLen = u_unescape(rule1, string, 256);
+ coll = ucol_open("root", &status);
+ if(U_FAILURE(status)) {
+ log_err_status(status, "Couldn't open UCA -> %s\n", u_errorName(status));
+ return;
+ }
+ ucol_setStrength(coll, UCOL_PRIMARY);
+ ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_PRIMARY, &status);
+ ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
+ if (U_FAILURE(status)) {
+ log_err("Failed setting atributes\n");
+ return;
+ }
- coll = ucol_openRules(string, uStringLen, UCOL_DEFAULT, UCOL_DEFAULT, NULL, &status);
+ sortkey_length = ucol_getSortKey(coll, ustr, ustr_length, shortKeyBuf, sizeof(shortKeyBuf));
+ if (sortkey_length != 4) {
+ log_err("expecting length of sortKey is 4 got:%d ", sortkey_length);
+ }
+ log_verbose("length of sortKey is %d", sortkey_length);
ucol_close(coll);
- }
+}
+#define TSKC_DATA_SIZE 5
+#define TSKC_BUF_SIZE 50
+static void
+TestSortKeyConsistency(void)
+{
+ UErrorCode icuRC = U_ZERO_ERROR;
+ UCollator* ucol;
+ UChar data[] = { 0xFFFD, 0x0006, 0x0006, 0x0006, 0xFFFD};
-}
+ uint8_t bufFull[TSKC_DATA_SIZE][TSKC_BUF_SIZE];
+ uint8_t bufPart[TSKC_DATA_SIZE][TSKC_BUF_SIZE];
+ int32_t i, j, i2;
-/*
-[last variable] last variable value
-[last primary ignorable] largest CE for primary ignorable
-[last secondary ignorable] largest CE for secondary ignorable
-[last tertiary ignorable] largest CE for tertiary ignorable
-[top] guaranteed to be above all implicit CEs, for now and in the future (in 1.8)
-*/
+ ucol = ucol_openFromShortString("LEN_S4", FALSE, NULL, &icuRC);
+ if (U_FAILURE(icuRC))
+ {
+ log_err_status(icuRC, "ucol_openFromShortString failed -> %s\n", u_errorName(icuRC));
+ return;
+ }
-static void TestRuleOptions(void) {
- /* values here are hardcoded and are correct for the current UCA
- * when the UCA changes, one might be forced to change these
- * values. (\\u02d0, \\U00010FFFC etc...)
- */
- static struct {
- const char *rules;
- const char *data[50];
- const uint32_t len;
- } tests[] = {
- /* - all befores here amount to zero */
- { "&[before 3][first tertiary ignorable]<<<a",
- { "\\u0000", "a"}, 2
- }, /* you cannot go before first tertiary ignorable */
+ for (i = 0; i < TSKC_DATA_SIZE; i++)
+ {
+ UCharIterator uiter;
+ uint32_t state[2] = { 0, 0 };
+ int32_t dataLen = i+1;
+ for (j=0; j<TSKC_BUF_SIZE; j++)
+ bufFull[i][j] = bufPart[i][j] = 0;
+
+ /* Full sort key */
+ ucol_getSortKey(ucol, data, dataLen, bufFull[i], TSKC_BUF_SIZE);
+
+ /* Partial sort key */
+ uiter_setString(&uiter, data, dataLen);
+ ucol_nextSortKeyPart(ucol, &uiter, state, bufPart[i], TSKC_BUF_SIZE, &icuRC);
+ if (U_FAILURE(icuRC))
+ {
+ log_err("ucol_nextSortKeyPart failed\n");
+ ucol_close(ucol);
+ return;
+ }
- { "&[before 3][last tertiary ignorable]<<<a",
- { "\\u0000", "a"}, 2
- }, /* you cannot go before last tertiary ignorable */
+ for (i2=0; i2<i; i2++)
+ {
+ UBool fullMatch = TRUE;
+ UBool partMatch = TRUE;
+ for (j=0; j<TSKC_BUF_SIZE; j++)
+ {
+ fullMatch = fullMatch && (bufFull[i][j] != bufFull[i2][j]);
+ partMatch = partMatch && (bufPart[i][j] != bufPart[i2][j]);
+ }
+ if (fullMatch != partMatch) {
+ log_err(fullMatch ? "full key was consistent, but partial key changed\n"
+ : "partial key was consistent, but full key changed\n");
+ ucol_close(ucol);
+ return;
+ }
+ }
+ }
- { "&[before 3][first secondary ignorable]<<<a",
- { "\\u0000", "a"}, 2
- }, /* you cannot go before first secondary ignorable */
+ /*=============================================*/
+ ucol_close(ucol);
+}
- { "&[before 3][last secondary ignorable]<<<a",
- { "\\u0000", "a"}, 2
- }, /* you cannot go before first secondary ignorable */
+/* ticket: 6101 */
+static void TestCroatianSortKey(void) {
+ const char* collString = "LHR_AN_CX_EX_FX_HX_NX_S3";
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *ucol;
+ UCharIterator iter;
- /* 'normal' befores */
+ static const UChar text[] = { 0x0044, 0xD81A };
- { "&[before 3][first primary ignorable]<<<c<<<b &[first primary ignorable]<a",
- { "c", "b", "\\u0332", "a" }, 4
- },
+ size_t length = UPRV_LENGTHOF(text);
- /* we don't have a code point that corresponds to
- * the last primary ignorable
- */
- { "&[before 3][last primary ignorable]<<<c<<<b &[last primary ignorable]<a",
- { "\\u0332", "\\u20e3", "c", "b", "a" }, 5
- },
+ uint8_t textSortKey[32];
+ size_t lenSortKey = 32;
+ size_t actualSortKeyLen;
+ uint32_t uStateInfo[2] = { 0, 0 };
- { "&[before 3][first variable]<<<c<<<b &[first variable]<a",
- { "c", "b", "\\u0009", "a", "\\u000a" }, 5
- },
+ ucol = ucol_openFromShortString(collString, FALSE, NULL, &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ucol_openFromShortString error in Craotian test. -> %s\n", u_errorName(status));
+ return;
+ }
- { "&[last variable]<a &[before 3][last variable]<<<c<<<b ",
- { "c", "b", "\\uD800\\uDD33", "a", "\\u02d0" }, 5
- },
+ uiter_setString(&iter, text, (int32_t)length);
- { "&[first regular]<a"
- "&[before 1][first regular]<b",
- { "b", "\\u02d0", "a", "\\u02d1"}, 4
- },
+ actualSortKeyLen = ucol_nextSortKeyPart(
+ ucol, &iter, (uint32_t*)uStateInfo,
+ textSortKey, (int32_t)lenSortKey, &status
+ );
- { "&[before 1][last regular]<b"
- "&[last regular]<a",
- { "b", "\\uD800\\uDF9D", "a", "\\u4e00" }, 4
- },
+ if (actualSortKeyLen == lenSortKey) {
+ log_err("ucol_nextSortKeyPart did not give correct result in Croatian test.\n");
+ }
- { "&[before 1][first implicit]<b"
- "&[first implicit]<a",
- { "b", "\\u4e00", "a", "\\u4e01"}, 4
- },
+ ucol_close(ucol);
+}
- { "&[before 1][last implicit]<b"
- "&[last implicit]<a",
- { "b", "\\U0010FFFD", "a" }, 3
- },
+/* ticket: 6140 */
+/* This test ensures that codepoints such as 0x3099 are flagged correctly by the collator since
+ * they are both Hiragana and Katakana
+ */
+#define SORTKEYLEN 50
+static void TestHiragana(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator* ucol;
+ UCollationResult strcollresult;
+ UChar data1[] = { 0x3058, 0x30B8 }; /* Hiragana and Katakana letter Zi */
+ UChar data2[] = { 0x3057, 0x3099, 0x30B7, 0x3099 };
+ int32_t data1Len = UPRV_LENGTHOF(data1);
+ int32_t data2Len = UPRV_LENGTHOF(data2);
+ int32_t i, j;
+ uint8_t sortKey1[SORTKEYLEN];
+ uint8_t sortKey2[SORTKEYLEN];
+
+ UCharIterator uiter1;
+ UCharIterator uiter2;
+ uint32_t state1[2] = { 0, 0 };
+ uint32_t state2[2] = { 0, 0 };
+ int32_t keySize1;
+ int32_t keySize2;
+
+ ucol = ucol_openFromShortString("LJA_AN_CX_EX_FX_HO_NX_S4", FALSE, NULL,
+ &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "Error status: %s; Unable to open collator from short string.\n", u_errorName(status));
+ return;
+ }
- { "&[last variable]<z"
- "&[last primary ignorable]<x"
- "&[last secondary ignorable]<<y"
- "&[last tertiary ignorable]<<<w"
- "&[top]<u",
- {"\\ufffb", "w", "y", "\\u20e3", "x", "\\u137c", "z", "u"}, 7
+ /* Start of full sort keys */
+ /* Full sort key1 */
+ keySize1 = ucol_getSortKey(ucol, data1, data1Len, sortKey1, SORTKEYLEN);
+ /* Full sort key2 */
+ keySize2 = ucol_getSortKey(ucol, data2, data2Len, sortKey2, SORTKEYLEN);
+ if (keySize1 == keySize2) {
+ for (i = 0; i < keySize1; i++) {
+ if (sortKey1[i] != sortKey2[i]) {
+ log_err("Full sort keys are different. Should be equal.");
+ }
+ }
+ } else {
+ log_err("Full sort keys sizes doesn't match: %d %d", keySize1, keySize2);
+ }
+ /* End of full sort keys */
+
+ /* Start of partial sort keys */
+ /* Partial sort key1 */
+ uiter_setString(&uiter1, data1, data1Len);
+ keySize1 = ucol_nextSortKeyPart(ucol, &uiter1, state1, sortKey1, SORTKEYLEN, &status);
+ /* Partial sort key2 */
+ uiter_setString(&uiter2, data2, data2Len);
+ keySize2 = ucol_nextSortKeyPart(ucol, &uiter2, state2, sortKey2, SORTKEYLEN, &status);
+ if (U_SUCCESS(status) && keySize1 == keySize2) {
+ for (j = 0; j < keySize1; j++) {
+ if (sortKey1[j] != sortKey2[j]) {
+ log_err("Partial sort keys are different. Should be equal");
+ }
+ }
+ } else {
+ log_err("Error Status: %s or Partial sort keys sizes doesn't match: %d %d", u_errorName(status), keySize1, keySize2);
}
+ /* End of partial sort keys */
- };
- uint32_t i;
+ /* Start of strcoll */
+ /* Use ucol_strcoll() to determine ordering */
+ strcollresult = ucol_strcoll(ucol, data1, data1Len, data2, data2Len);
+ if (strcollresult != UCOL_EQUAL) {
+ log_err("Result from ucol_strcoll() should be UCOL_EQUAL.");
+ }
+
+ ucol_close(ucol);
+}
+
+/* Convenient struct for running collation tests */
+typedef struct {
+ const UChar source[MAX_TOKEN_LEN]; /* String on left */
+ const UChar target[MAX_TOKEN_LEN]; /* String on right */
+ UCollationResult result; /* -1, 0 or +1, depending on collation */
+} OneTestCase;
+
+/*
+ * Utility function to test one collation test case.
+ * @param testcases Array of test cases.
+ * @param n_testcases Size of the array testcases.
+ * @param str_rules Array of rules. These rules should be specifying the same rule in different formats.
+ * @param n_rules Size of the array str_rules.
+ */
+static void doTestOneTestCase(const OneTestCase testcases[],
+ int n_testcases,
+ const char* str_rules[],
+ int n_rules)
+{
+ int rule_no, testcase_no;
+ UChar rule[500];
+ int32_t length = 0;
+ UErrorCode status = U_ZERO_ERROR;
+ UParseError parse_error;
+ UCollator *myCollation;
+ for (rule_no = 0; rule_no < n_rules; ++rule_no) {
- for(i = 0; i<(sizeof(tests)/sizeof(tests[0])); i++) {
- genericRulesStarter(tests[i].rules, tests[i].data, tests[i].len);
+ length = u_unescape(str_rules[rule_no], rule, 500);
+ if (length == 0) {
+ log_err("ERROR: The rule cannot be unescaped: %s\n");
+ return;
+ }
+ myCollation = ucol_openRules(rule, length, UCOL_ON, UCOL_TERTIARY, &parse_error, &status);
+ if(U_FAILURE(status)){
+ log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
+ log_info(" offset=%d \"%s\" | \"%s\"\n",
+ parse_error.offset,
+ aescstrdup(parse_error.preContext, -1),
+ aescstrdup(parse_error.postContext, -1));
+ return;
+ }
+ log_verbose("Testing the <<* syntax\n");
+ ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
+ ucol_setStrength(myCollation, UCOL_TERTIARY);
+ for (testcase_no = 0; testcase_no < n_testcases; ++testcase_no) {
+ doTest(myCollation,
+ testcases[testcase_no].source,
+ testcases[testcase_no].target,
+ testcases[testcase_no].result
+ );
+ }
+ ucol_close(myCollation);
}
}
+const static OneTestCase rangeTestcases[] = {
+ { {0x0061}, {0x0062}, UCOL_LESS }, /* "a" < "b" */
+ { {0x0062}, {0x0063}, UCOL_LESS }, /* "b" < "c" */
+ { {0x0061}, {0x0063}, UCOL_LESS }, /* "a" < "c" */
+
+ { {0x0062}, {0x006b}, UCOL_LESS }, /* "b" << "k" */
+ { {0x006b}, {0x006c}, UCOL_LESS }, /* "k" << "l" */
+ { {0x0062}, {0x006c}, UCOL_LESS }, /* "b" << "l" */
+ { {0x0061}, {0x006c}, UCOL_LESS }, /* "a" < "l" */
+ { {0x0061}, {0x006d}, UCOL_LESS }, /* "a" < "m" */
+
+ { {0x0079}, {0x006d}, UCOL_LESS }, /* "y" < "f" */
+ { {0x0079}, {0x0067}, UCOL_LESS }, /* "y" < "g" */
+ { {0x0061}, {0x0068}, UCOL_LESS }, /* "y" < "h" */
+ { {0x0061}, {0x0065}, UCOL_LESS }, /* "g" < "e" */
+
+ { {0x0061}, {0x0031}, UCOL_EQUAL }, /* "a" = "1" */
+ { {0x0061}, {0x0032}, UCOL_EQUAL }, /* "a" = "2" */
+ { {0x0061}, {0x0033}, UCOL_EQUAL }, /* "a" = "3" */
+ { {0x0061}, {0x0066}, UCOL_LESS }, /* "a" < "f" */
+ { {0x006c, 0x0061}, {0x006b, 0x0062}, UCOL_LESS }, /* "la" < "123" */
+ { {0x0061, 0x0061, 0x0061}, {0x0031, 0x0032, 0x0033}, UCOL_EQUAL }, /* "aaa" = "123" */
+ { {0x0062}, {0x007a}, UCOL_LESS }, /* "b" < "z" */
+ { {0x0061, 0x007a, 0x0062}, {0x0032, 0x0079, 0x006d}, UCOL_LESS }, /* "azm" = "2yc" */
+};
-static void TestOptimize(void) {
- /* this is not really a test - just trying out
- * whether copying of UCA contents will fail
- * Cannot really test, since the functionality
- * remains the same.
- */
- static struct {
- const char *rules;
- const char *data[50];
- const uint32_t len;
- } tests[] = {
- /* - all befores here amount to zero */
- { "[optimize [\\uAC00-\\uD7FF]]",
- { "a", "b"}, 2}
- };
- uint32_t i;
+static int nRangeTestcases = UPRV_LENGTHOF(rangeTestcases);
- for(i = 0; i<(sizeof(tests)/sizeof(tests[0])); i++) {
- genericRulesStarter(tests[i].rules, tests[i].data, tests[i].len);
- }
-}
+const static OneTestCase rangeTestcasesSupplemental[] = {
+ { {0x4e00}, {0xfffb}, UCOL_LESS }, /* U+4E00 < U+FFFB */
+ { {0xfffb}, {0xd800, 0xdc00}, UCOL_LESS }, /* U+FFFB < U+10000 */
+ { {0xd800, 0xdc00}, {0xd800, 0xdc01}, UCOL_LESS }, /* U+10000 < U+10001 */
+ { {0x4e00}, {0xd800, 0xdc01}, UCOL_LESS }, /* U+4E00 < U+10001 */
+ { {0xd800, 0xdc01}, {0xd800, 0xdc02}, UCOL_LESS }, /* U+10000 < U+10001 */
+ { {0xd800, 0xdc01}, {0xd800, 0xdc02}, UCOL_LESS }, /* U+10000 < U+10001 */
+ { {0x4e00}, {0xd800, 0xdc02}, UCOL_LESS }, /* U+4E00 < U+10001 */
+};
-/*
-cycheng@ca.ibm.c... we got inconsistent results when using the UTF-16BE iterator and the UTF-8 iterator.
-weiv ucol_strcollIter?
-cycheng@ca.ibm.c... e.g. s1 = 0xfffc0062, and s2 = d8000021
-weiv these are the input strings?
-cycheng@ca.ibm.c... yes, using the utf-16 iterator and UCA with normalization on, we have s1 > s2
-weiv will check - could be a problem with utf-8 iterator
-cycheng@ca.ibm.c... but if we use the utf-8 iterator, i.e. s1 = efbfbc62 and s2 = eda08021, we have s1 < s2
-weiv hmmm
-cycheng@ca.ibm.c... note that we have a standalone high surrogate
-weiv that doesn't sound right
-cycheng@ca.ibm.c... we got the same inconsistent results on AIX and Win2000
-weiv so you have two strings, you convert them to utf-8 and to utf-16BE
-cycheng@ca.ibm.c... yes
-weiv and then do the comparison
-cycheng@ca.ibm.c... in one case, the input strings are in utf8, and in the other case the input strings are in utf-16be
-weiv utf-16 strings look like a little endian ones in the example you sent me
-weiv It could be a bug - let me try to test it out
-cycheng@ca.ibm.c... ok
-cycheng@ca.ibm.c... we can wait till the conf. call
-cycheng@ca.ibm.c... next weke
-weiv that would be great
-weiv hmmm
-weiv I might be wrong
-weiv let me play with it some more
-cycheng@ca.ibm.c... ok
-cycheng@ca.ibm.c... also please check s3 = 0x0e3a0062 and s4 = 0x0e400021. both are in utf-16be
-cycheng@ca.ibm.c... seems with icu 2.2 we have s3 > s4, but not in icu 2.4 that's built for db2
-cycheng@ca.ibm.c... also s1 & s2 that I sent you earlier are also in utf-16be
-weiv ok
-cycheng@ca.ibm.c... i ask sherman to send you more inconsistent data
-weiv thanks
-cycheng@ca.ibm.c... the 4 strings we sent are just samples
-*/
-#if 0
-static void Alexis(void) {
- UErrorCode status = U_ZERO_ERROR;
- UCollator *coll = ucol_open("", &status);
+static int nRangeTestcasesSupplemental = UPRV_LENGTHOF(rangeTestcasesSupplemental);
+const static OneTestCase rangeTestcasesQwerty[] = {
+ { {0x0071}, {0x0077}, UCOL_LESS }, /* "q" < "w" */
+ { {0x0077}, {0x0065}, UCOL_LESS }, /* "w" < "e" */
- const char utf16be[2][4] = {
- { (char)0xd8, (char)0x00, (char)0x00, (char)0x21 },
- { (char)0xff, (char)0xfc, (char)0x00, (char)0x62 }
- };
+ { {0x0079}, {0x0075}, UCOL_LESS }, /* "y" < "u" */
+ { {0x0071}, {0x0075}, UCOL_LESS }, /* "q" << "u" */
- const char utf8[2][4] = {
- { (char)0xed, (char)0xa0, (char)0x80, (char)0x21 },
- { (char)0xef, (char)0xbf, (char)0xbc, (char)0x62 },
- };
+ { {0x0074}, {0x0069}, UCOL_LESS }, /* "t" << "i" */
+ { {0x006f}, {0x0070}, UCOL_LESS }, /* "o" << "p" */
- UCharIterator iterU161, iterU162;
- UCharIterator iterU81, iterU82;
+ { {0x0079}, {0x0065}, UCOL_LESS }, /* "y" < "e" */
+ { {0x0069}, {0x0075}, UCOL_LESS }, /* "i" < "u" */
- UCollationResult resU16, resU8;
+ { {0x0071, 0x0075, 0x0065, 0x0073, 0x0074},
+ {0x0077, 0x0065, 0x0072, 0x0065}, UCOL_LESS }, /* "quest" < "were" */
+ { {0x0071, 0x0075, 0x0061, 0x0063, 0x006b},
+ {0x0071, 0x0075, 0x0065, 0x0073, 0x0074}, UCOL_LESS }, /* "quack" < "quest" */
+};
- uiter_setUTF16BE(&iterU161, utf16be[0], 4);
- uiter_setUTF16BE(&iterU162, utf16be[1], 4);
+static int nRangeTestcasesQwerty = UPRV_LENGTHOF(rangeTestcasesQwerty);
- uiter_setUTF8(&iterU81, utf8[0], 4);
- uiter_setUTF8(&iterU82, utf8[1], 4);
+static void TestSameStrengthList(void)
+{
+ const char* strRules[] = {
+ /* Normal */
+ "&a<b<c<d &b<<k<<l<<m &k<<<x<<<y<<<z &y<f<g<h<e &a=1=2=3",
- ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
+ /* Lists */
+ "&a<*bcd &b<<*klm &k<<<*xyz &y<*fghe &a=*123",
+ };
+ doTestOneTestCase(rangeTestcases, nRangeTestcases, strRules, UPRV_LENGTHOF(strRules));
+}
- resU16 = ucol_strcollIter(coll, &iterU161, &iterU162, &status);
- resU8 = ucol_strcollIter(coll, &iterU81, &iterU82, &status);
+static void TestSameStrengthListQuoted(void)
+{
+ const char* strRules[] = {
+ /* Lists with quoted characters */
+ "&\\u0061<*bcd &b<<*klm &k<<<*xyz &y<*f\\u0067\\u0068e &a=*123",
+ "&'\\u0061'<*bcd &b<<*klm &k<<<*xyz &y<*f'\\u0067\\u0068'e &a=*123",
+ "&\\u0061<*b\\u0063d &b<<*klm &k<<<*xyz &\\u0079<*fgh\\u0065 &a=*\\u0031\\u0032\\u0033",
+ "&'\\u0061'<*b'\\u0063'd &b<<*klm &k<<<*xyz &'\\u0079'<*fgh'\\u0065' &a=*'\\u0031\\u0032\\u0033'",
- if(resU16 != resU8) {
- log_err("different results\n");
- }
+ "&\\u0061<*\\u0062c\\u0064 &b<<*klm &k<<<*xyz &y<*fghe &a=*\\u0031\\u0032\\u0033",
+ "&'\\u0061'<*'\\u0062'c'\\u0064' &b<<*klm &k<<<*xyz &y<*fghe &a=*'\\u0031\\u0032\\u0033'",
+ };
+ doTestOneTestCase(rangeTestcases, nRangeTestcases, strRules, UPRV_LENGTHOF(strRules));
+}
- ucol_close(coll);
+static void TestSameStrengthListSupplemental(void)
+{
+ const char* strRules[] = {
+ "&\\u4e00<\\ufffb<\\U00010000<\\U00010001<\\U00010002",
+ "&\\u4e00<\\ufffb<\\ud800\\udc00<\\ud800\\udc01<\\ud800\\udc02",
+ "&\\u4e00<*\\ufffb\\U00010000\\U00010001\\U00010002",
+ "&\\u4e00<*\\ufffb\\ud800\\udc00\\ud800\\udc01\\ud800\\udc02",
+ };
+ doTestOneTestCase(rangeTestcasesSupplemental, nRangeTestcasesSupplemental, strRules, UPRV_LENGTHOF(strRules));
}
-#endif
-#define CMSCOLL_ALEXIS2_BUFFER_SIZE 256
-static void Alexis2(void) {
- UErrorCode status = U_ZERO_ERROR;
- UChar U16Source[CMSCOLL_ALEXIS2_BUFFER_SIZE], U16Target[CMSCOLL_ALEXIS2_BUFFER_SIZE];
- char U16BESource[CMSCOLL_ALEXIS2_BUFFER_SIZE], U16BETarget[CMSCOLL_ALEXIS2_BUFFER_SIZE];
- char U8Source[CMSCOLL_ALEXIS2_BUFFER_SIZE], U8Target[CMSCOLL_ALEXIS2_BUFFER_SIZE];
- int32_t U16LenS = 0, U16LenT = 0, U16BELenS = 0, U16BELenT = 0, U8LenS = 0, U8LenT = 0;
+static void TestSameStrengthListQwerty(void)
+{
+ const char* strRules[] = {
+ "&q<w<e<r &w<<t<<y<<u &t<<<i<<<o<<<p &o=a=s=d", /* Normal */
+ "&q<*wer &w<<*tyu &t<<<*iop &o=*asd", /* Lists */
+ "&\\u0071<\\u0077<\\u0065<\\u0072 &\\u0077<<\\u0074<<\\u0079<<\\u0075 &\\u0074<<<\\u0069<<<\\u006f<<<\\u0070 &\\u006f=\\u0061=\\u0073=\\u0064",
+ "&'\\u0071'<\\u0077<\\u0065<\\u0072 &\\u0077<<'\\u0074'<<\\u0079<<\\u0075 &\\u0074<<<\\u0069<<<'\\u006f'<<<\\u0070 &\\u006f=\\u0061='\\u0073'=\\u0064",
+ "&\\u0071<*\\u0077\\u0065\\u0072 &\\u0077<<*\\u0074\\u0079\\u0075 &\\u0074<<<*\\u0069\\u006f\\u0070 &\\u006f=*\\u0061\\u0073\\u0064",
- UConverter *conv = NULL;
+ /* Quoted characters also will work if two quoted characters are not consecutive. */
+ "&\\u0071<*'\\u0077'\\u0065\\u0072 &\\u0077<<*\\u0074'\\u0079'\\u0075 &\\u0074<<<*\\u0069\\u006f'\\u0070' &'\\u006f'=*\\u0061\\u0073\\u0064",
- UCharIterator U16BEItS, U16BEItT;
- UCharIterator U8ItS, U8ItT;
+ /* Consecutive quoted charactes do not work, because a '' will be treated as a quote character. */
+ /* "&\\u0071<*'\\u0077''\\u0065''\\u0072' &\\u0077<<*'\\u0074''\\u0079''\\u0075' &\\u0074<<<*'\\u0069''\\u006f''\\u0070' &'\\u006f'=*\\u0061\\u0073\\u0064",*/
- UCollationResult resU16, resU16BE, resU8;
+ };
+ doTestOneTestCase(rangeTestcasesQwerty, nRangeTestcasesQwerty, strRules, UPRV_LENGTHOF(strRules));
+}
- const char* pairs[][2] = {
- { "\\ud800\\u0021", "\\uFFFC\\u0062"},
- { "\\u0435\\u0308\\u0334", "\\u0415\\u0334\\u0340" },
- { "\\u0E40\\u0021", "\\u00A1\\u0021"},
- { "\\u0E40\\u0021", "\\uFE57\\u0062"},
- { "\\u5F20", "\\u5F20\\u4E00\\u8E3F"},
- { "\\u0000\\u0020", "\\u0000\\u0020\\u0000"},
- { "\\u0020", "\\u0020\\u0000"}
-/*
-5F20 (my result here)
-5F204E008E3F
-5F20 (your result here)
-*/
+static void TestSameStrengthListQuotedQwerty(void)
+{
+ const char* strRules[] = {
+ "&q<w<e<r &w<<t<<y<<u &t<<<i<<<o<<<p &o=a=s=d", /* Normal */
+ "&q<*wer &w<<*tyu &t<<<*iop &o=*asd", /* Lists */
+ "&q<*w'e'r &w<<*'t'yu &t<<<*io'p' &o=*'a's'd'", /* Lists with quotes */
+
+ /* Lists with continuous quotes may not work, because '' will be treated as a quote character. */
+ /* "&q<*'w''e''r' &w<<*'t''y''u' &t<<<*'i''o''p' &o=*'a''s''d'", */
+ };
+ doTestOneTestCase(rangeTestcasesQwerty, nRangeTestcasesQwerty, strRules, UPRV_LENGTHOF(strRules));
+}
+
+static void TestSameStrengthListRanges(void)
+{
+ const char* strRules[] = {
+ "&a<*b-d &b<<*k-m &k<<<*x-z &y<*f-he &a=*1-3",
};
+ doTestOneTestCase(rangeTestcases, nRangeTestcases, strRules, UPRV_LENGTHOF(strRules));
+}
- int32_t i = 0;
+static void TestSameStrengthListSupplementalRanges(void)
+{
+ const char* strRules[] = {
+ /* Note: U+FFFD..U+FFFF are not tailorable, so a range cannot include them. */
+ "&\\u4e00<*\\ufffb\\U00010000-\\U00010002",
+ };
+ doTestOneTestCase(rangeTestcasesSupplemental, nRangeTestcasesSupplemental, strRules, UPRV_LENGTHOF(strRules));
+}
- UCollator *coll = ucol_open("", &status);
- if(status == U_FILE_ACCESS_ERROR) {
- log_data_err("Is your data around?\n");
- return;
- } else if(U_FAILURE(status)) {
- log_err("Error opening collator\n");
- return;
- }
- ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
- conv = ucnv_open("UTF16BE", &status);
- for(i = 0; i < sizeof(pairs)/sizeof(pairs[0]); i++) {
- U16LenS = u_unescape(pairs[i][0], U16Source, CMSCOLL_ALEXIS2_BUFFER_SIZE);
- U16LenT = u_unescape(pairs[i][1], U16Target, CMSCOLL_ALEXIS2_BUFFER_SIZE);
+static void TestSpecialCharacters(void)
+{
+ const char* strRules[] = {
+ /* Normal */
+ "&';'<'+'<','<'-'<'&'<'*'",
- resU16 = ucol_strcoll(coll, U16Source, U16LenS, U16Target, U16LenT);
+ /* List */
+ "&';'<*'+,-&*'",
- log_verbose("Result of strcoll is %i\n", resU16);
+ /* Range */
+ "&';'<*'+'-'-&*'",
+ };
- U16BELenS = ucnv_fromUChars(conv, U16BESource, CMSCOLL_ALEXIS2_BUFFER_SIZE, U16Source, U16LenS, &status);
- U16BELenT = ucnv_fromUChars(conv, U16BETarget, CMSCOLL_ALEXIS2_BUFFER_SIZE, U16Target, U16LenT, &status);
+ const static OneTestCase specialCharacterStrings[] = {
+ { {0x003b}, {0x002b}, UCOL_LESS }, /* ; < + */
+ { {0x002b}, {0x002c}, UCOL_LESS }, /* + < , */
+ { {0x002c}, {0x002d}, UCOL_LESS }, /* , < - */
+ { {0x002d}, {0x0026}, UCOL_LESS }, /* - < & */
+ };
+ doTestOneTestCase(specialCharacterStrings, UPRV_LENGTHOF(specialCharacterStrings), strRules, UPRV_LENGTHOF(strRules));
+}
- /* use the original sizes, as the result from converter is in bytes */
- uiter_setUTF16BE(&U16BEItS, U16BESource, U16LenS);
- uiter_setUTF16BE(&U16BEItT, U16BETarget, U16LenT);
+static void TestPrivateUseCharacters(void)
+{
+ const char* strRules[] = {
+ /* Normal */
+ "&'\\u5ea7'<'\\uE2D8'<'\\uE2D9'<'\\uE2DA'<'\\uE2DB'<'\\uE2DC'<'\\u4e8d'",
+ "&\\u5ea7<\\uE2D8<\\uE2D9<\\uE2DA<\\uE2DB<\\uE2DC<\\u4e8d",
+ };
- resU16BE = ucol_strcollIter(coll, &U16BEItS, &U16BEItT, &status);
+ const static OneTestCase privateUseCharacterStrings[] = {
+ { {0x5ea7}, {0xe2d8}, UCOL_LESS },
+ { {0xe2d8}, {0xe2d9}, UCOL_LESS },
+ { {0xe2d9}, {0xe2da}, UCOL_LESS },
+ { {0xe2da}, {0xe2db}, UCOL_LESS },
+ { {0xe2db}, {0xe2dc}, UCOL_LESS },
+ { {0xe2dc}, {0x4e8d}, UCOL_LESS },
+ };
+ doTestOneTestCase(privateUseCharacterStrings, UPRV_LENGTHOF(privateUseCharacterStrings), strRules, UPRV_LENGTHOF(strRules));
+}
- log_verbose("Result of U16BE is %i\n", resU16BE);
+static void TestPrivateUseCharactersInList(void)
+{
+ const char* strRules[] = {
+ /* List */
+ "&'\\u5ea7'<*'\\uE2D8\\uE2D9\\uE2DA\\uE2DB\\uE2DC\\u4e8d'",
+ /* "&'\\u5ea7'<*\\uE2D8'\\uE2D9\\uE2DA'\\uE2DB'\\uE2DC\\u4e8d'", */
+ "&\\u5ea7<*\\uE2D8\\uE2D9\\uE2DA\\uE2DB\\uE2DC\\u4e8d",
+ };
- if(resU16 != resU16BE) {
- log_verbose("Different results between UTF16 and UTF16BE for %s & %s\n", pairs[i][0], pairs[i][1]);
- }
+ const static OneTestCase privateUseCharacterStrings[] = {
+ { {0x5ea7}, {0xe2d8}, UCOL_LESS },
+ { {0xe2d8}, {0xe2d9}, UCOL_LESS },
+ { {0xe2d9}, {0xe2da}, UCOL_LESS },
+ { {0xe2da}, {0xe2db}, UCOL_LESS },
+ { {0xe2db}, {0xe2dc}, UCOL_LESS },
+ { {0xe2dc}, {0x4e8d}, UCOL_LESS },
+ };
+ doTestOneTestCase(privateUseCharacterStrings, UPRV_LENGTHOF(privateUseCharacterStrings), strRules, UPRV_LENGTHOF(strRules));
+}
- u_strToUTF8(U8Source, CMSCOLL_ALEXIS2_BUFFER_SIZE, &U8LenS, U16Source, U16LenS, &status);
- u_strToUTF8(U8Target, CMSCOLL_ALEXIS2_BUFFER_SIZE, &U8LenT, U16Target, U16LenT, &status);
+static void TestPrivateUseCharactersInRange(void)
+{
+ const char* strRules[] = {
+ /* Range */
+ "&'\\u5ea7'<*'\\uE2D8'-'\\uE2DC\\u4e8d'",
+ "&\\u5ea7<*\\uE2D8-\\uE2DC\\u4e8d",
+ /* "&\\u5ea7<\\uE2D8'\\uE2D8'-'\\uE2D9'\\uE2DA-\\uE2DB\\uE2DC\\u4e8d", */
+ };
- uiter_setUTF8(&U8ItS, U8Source, U8LenS);
- uiter_setUTF8(&U8ItT, U8Target, U8LenT);
+ const static OneTestCase privateUseCharacterStrings[] = {
+ { {0x5ea7}, {0xe2d8}, UCOL_LESS },
+ { {0xe2d8}, {0xe2d9}, UCOL_LESS },
+ { {0xe2d9}, {0xe2da}, UCOL_LESS },
+ { {0xe2da}, {0xe2db}, UCOL_LESS },
+ { {0xe2db}, {0xe2dc}, UCOL_LESS },
+ { {0xe2dc}, {0x4e8d}, UCOL_LESS },
+ };
+ doTestOneTestCase(privateUseCharacterStrings, UPRV_LENGTHOF(privateUseCharacterStrings), strRules, UPRV_LENGTHOF(strRules));
+}
- resU8 = ucol_strcollIter(coll, &U8ItS, &U8ItT, &status);
+static void TestInvalidListsAndRanges(void)
+{
+ const char* invalidRules[] = {
+ /* Range not in starred expression */
+ "&\\ufffe<\\uffff-\\U00010002",
- if(resU16 != resU8) {
- log_verbose("Different results between UTF16 and UTF8 for %s & %s\n", pairs[i][0], pairs[i][1]);
- }
+ /* Range without start */
+ "&a<*-c",
- }
+ /* Range without end */
+ "&a<*b-",
- ucol_close(coll);
- ucnv_close(conv);
-}
+ /* More than one hyphen */
+ "&a<*b-g-l",
-static void TestHebrewUCA(void) {
- UErrorCode status = U_ZERO_ERROR;
- const char *first[] = {
- "d790d6b8d79cd795d6bcd7a9",
- "d790d79cd79ed7a7d799d799d7a1",
- "d790d6b4d79ed795d6bcd7a9",
- };
+ /* Range in the wrong order */
+ "&a<*k-b",
- char utf8String[3][256];
- UChar utf16String[3][256];
+ };
- int32_t i = 0, j = 0;
- int32_t sizeUTF8[3];
- int32_t sizeUTF16[3];
+ UChar rule[500];
+ UErrorCode status = U_ZERO_ERROR;
+ UParseError parse_error;
+ int n_rules = UPRV_LENGTHOF(invalidRules);
+ int rule_no;
+ int length;
+ UCollator *myCollation;
- UCollator *coll = ucol_open("", &status);
- /*ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);*/
+ for (rule_no = 0; rule_no < n_rules; ++rule_no) {
- for(i = 0; i < sizeof(first)/sizeof(first[0]); i++) {
- sizeUTF8[i] = u_parseUTF8(first[i], -1, utf8String[i], 256, &status);
- u_strFromUTF8(utf16String[i], 256, &sizeUTF16[i], utf8String[i], sizeUTF8[i], &status);
- log_verbose("%i: ");
- for(j = 0; j < sizeUTF16[i]; j++) {
- /*log_verbose("\\u%04X", utf16String[i][j]);*/
- log_verbose("%04X", utf16String[i][j]);
+ length = u_unescape(invalidRules[rule_no], rule, 500);
+ if (length == 0) {
+ log_err("ERROR: The rule cannot be unescaped: %s\n");
+ return;
}
- log_verbose("\n");
- }
- for(i = 0; i < sizeof(first)/sizeof(first[0])-1; i++) {
- for(j = i + 1; j < sizeof(first)/sizeof(first[0]); j++) {
- doTest(coll, utf16String[i], utf16String[j], UCOL_LESS);
+ myCollation = ucol_openRules(rule, length, UCOL_ON, UCOL_TERTIARY, &parse_error, &status);
+ (void)myCollation; /* Suppress set but not used warning. */
+ if(!U_FAILURE(status)){
+ log_err("ERROR: Could not cause a failure as expected: \n");
}
+ status = U_ZERO_ERROR;
}
+}
- ucol_close(coll);
+/*
+ * This test ensures that characters placed before a character in a different script have the same lead byte
+ * in their collation key before and after script reordering.
+ */
+static void TestBeforeRuleWithScriptReordering(void)
+{
+ UParseError error;
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *myCollation;
+ char srules[500] = "&[before 1]\\u03b1 < \\u0e01";
+ UChar rules[500];
+ uint32_t rulesLength = 0;
+ int32_t reorderCodes[1] = {USCRIPT_GREEK};
+ UCollationResult collResult;
-}
+ uint8_t baseKey[256];
+ uint32_t baseKeyLength;
+ uint8_t beforeKey[256];
+ uint32_t beforeKeyLength;
-static void TestPartialSortKeyTermination(void) {
- const char* cases[] = {
- "\\u1234\\u1234\\udc00",
- "\\udc00\\ud800\\ud800"
- };
+ UChar base[] = { 0x03b1 }; /* base */
+ int32_t baseLen = UPRV_LENGTHOF(base);
- int32_t i = sizeof(UCollator);
+ UChar before[] = { 0x0e01 }; /* ko kai */
+ int32_t beforeLen = UPRV_LENGTHOF(before);
- UErrorCode status = U_ZERO_ERROR;
+ /*UChar *data[] = { before, base };
+ genericRulesStarter(srules, data, 2);*/
+
+ log_verbose("Testing the &[before 1] rule with [reorder grek]\n");
- UCollator *coll = ucol_open("", &status);
+ (void)beforeKeyLength; /* Suppress set but not used warnings. */
+ (void)baseKeyLength;
- UCharIterator iter;
+ /* build collator */
+ log_verbose("Testing the &[before 1] rule with [scriptReorder grek]\n");
- UChar currCase[256];
- int32_t length = 0;
- int32_t pKeyLen = 0;
+ rulesLength = u_unescape(srules, rules, UPRV_LENGTHOF(rules));
+ myCollation = ucol_openRules(rules, rulesLength, UCOL_ON, UCOL_TERTIARY, &error, &status);
+ if(U_FAILURE(status)) {
+ log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
+ return;
+ }
- uint8_t key[256];
+ /* check collation results - before rule applied but not script reordering */
+ collResult = ucol_strcoll(myCollation, base, baseLen, before, beforeLen);
+ if (collResult != UCOL_GREATER) {
+ log_err("Collation result not correct before script reordering = %d\n", collResult);
+ }
- for(i = 0; i < sizeof(cases)/sizeof(cases[0]); i++) {
- uint32_t state[2] = {0, 0};
- length = u_unescape(cases[i], currCase, 256);
- uiter_setString(&iter, currCase, length);
- pKeyLen = ucol_nextSortKeyPart(coll, &iter, state, key, 256, &status);
+ /* check the lead byte of the collation keys before script reordering */
+ baseKeyLength = ucol_getSortKey(myCollation, base, baseLen, baseKey, 256);
+ beforeKeyLength = ucol_getSortKey(myCollation, before, beforeLen, beforeKey, 256);
+ if (baseKey[0] != beforeKey[0]) {
+ log_err("Different lead byte for sort keys using before rule and before script reordering. base character lead byte = %02x, before character lead byte = %02x\n", baseKey[0], beforeKey[0]);
+ }
- log_verbose("Done\n");
+ /* reorder the scripts */
+ ucol_setReorderCodes(myCollation, reorderCodes, 1, &status);
+ if(U_FAILURE(status)) {
+ log_err_status(status, "ERROR: while setting script order: %s\n", myErrorName(status));
+ return;
+ }
- }
- ucol_close(coll);
-}
+ /* check collation results - before rule applied and after script reordering */
+ collResult = ucol_strcoll(myCollation, base, baseLen, before, beforeLen);
+ if (collResult != UCOL_GREATER) {
+ log_err("Collation result not correct after script reordering = %d\n", collResult);
+ }
+
+ /* check the lead byte of the collation keys after script reordering */
+ ucol_getSortKey(myCollation, base, baseLen, baseKey, 256);
+ ucol_getSortKey(myCollation, before, beforeLen, beforeKey, 256);
+ if (baseKey[0] != beforeKey[0]) {
+ log_err("Different lead byte for sort keys using before fule and after script reordering. base character lead byte = %02x, before character lead byte = %02x\n", baseKey[0], beforeKey[0]);
+ }
-static void TestSettings(void) {
- const char* cases[] = {
- "apple",
- "Apple"
- };
+ ucol_close(myCollation);
+}
- const char* locales[] = {
- "",
- "en"
- };
+/*
+ * Test that in a primary-compressed sort key all bytes except the first one are unchanged under script reordering.
+ */
+static void TestNonLeadBytesDuringCollationReordering(void)
+{
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *myCollation;
+ int32_t reorderCodes[1] = {USCRIPT_GREEK};
- UErrorCode status = U_ZERO_ERROR;
+ uint8_t baseKey[256];
+ uint32_t baseKeyLength;
+ uint8_t reorderKey[256];
+ uint32_t reorderKeyLength;
- int32_t i = 0, j = 0;
+ UChar testString[] = { 0x03b1, 0x03b2, 0x03b3 };
+
+ uint32_t i;
- UChar source[256], target[256];
- int32_t sLen = 0, tLen = 0;
- UCollator *collateObject = NULL;
- for(i = 0; i < sizeof(locales)/sizeof(locales[0]); i++) {
- collateObject = ucol_open(locales[i], &status);
- ucol_setStrength(collateObject, UCOL_PRIMARY);
- ucol_setAttribute(collateObject, UCOL_CASE_LEVEL , UCOL_OFF, &status);
- for(j = 1; j < sizeof(cases)/sizeof(cases[0]); j++) {
- sLen = u_unescape(cases[j-1], source, 256);
- source[sLen] = 0;
- tLen = u_unescape(cases[j], target, 256);
- source[tLen] = 0;
- doTest(collateObject, source, target, UCOL_EQUAL);
- }
- ucol_close(collateObject);
- }
-}
+ log_verbose("Testing non-lead bytes in a sort key with and without reordering\n");
-static int32_t TestEqualsForCollator(const char* locName, UCollator *source, UCollator *target) {
- UErrorCode status = U_ZERO_ERROR;
- int32_t errorNo = 0;
- /*const UChar *sourceRules = NULL;*/
- /*int32_t sourceRulesLen = 0;*/
- UColAttributeValue french = UCOL_OFF;
- int32_t cloneSize = 0;
-
- if(!ucol_equals(source, target)) {
- log_err("Same collators, different address not equal\n");
- errorNo++;
- }
- ucol_close(target);
- if(uprv_strcmp(ucol_getLocale(source, ULOC_REQUESTED_LOCALE, &status), ucol_getLocale(source, ULOC_ACTUAL_LOCALE, &status)) == 0) {
- /* currently, safeClone is implemented through getRules/openRules
- * so it is the same as the test below - I will comment that test out.
- */
- /* real thing */
- target = ucol_safeClone(source, NULL, &cloneSize, &status);
+ /* build collator tertiary */
+ myCollation = ucol_open("", &status);
+ ucol_setStrength(myCollation, UCOL_TERTIARY);
if(U_FAILURE(status)) {
- log_err("Error creating clone\n");
- errorNo++;
- return errorNo;
+ log_err_status(status, "ERROR: in creation of collator: %s\n", myErrorName(status));
+ return;
}
- if(!ucol_equals(source, target)) {
- log_err("Collator different from it's clone\n");
- errorNo++;
+ baseKeyLength = ucol_getSortKey(myCollation, testString, UPRV_LENGTHOF(testString), baseKey, 256);
+
+ ucol_setReorderCodes(myCollation, reorderCodes, UPRV_LENGTHOF(reorderCodes), &status);
+ if(U_FAILURE(status)) {
+ log_err_status(status, "ERROR: setting reorder codes: %s\n", myErrorName(status));
+ return;
}
- french = ucol_getAttribute(source, UCOL_FRENCH_COLLATION, &status);
- if(french == UCOL_ON) {
- ucol_setAttribute(target, UCOL_FRENCH_COLLATION, UCOL_OFF, &status);
- } else {
- ucol_setAttribute(target, UCOL_FRENCH_COLLATION, UCOL_ON, &status);
+ reorderKeyLength = ucol_getSortKey(myCollation, testString, UPRV_LENGTHOF(testString), reorderKey, 256);
+
+ if (baseKeyLength != reorderKeyLength) {
+ log_err("Key lengths not the same during reordering.\n");
+ return;
}
+
+ for (i = 1; i < baseKeyLength; i++) {
+ if (baseKey[i] != reorderKey[i]) {
+ log_err("Collation key bytes not the same at position %d.\n", i);
+ return;
+ }
+ }
+ ucol_close(myCollation);
+
+ /* build collator quaternary */
+ myCollation = ucol_open("", &status);
+ ucol_setStrength(myCollation, UCOL_QUATERNARY);
if(U_FAILURE(status)) {
- log_err("Error setting attributes\n");
- errorNo++;
- return errorNo;
- }
- if(ucol_equals(source, target)) {
- log_err("Collators same even when options changed\n");
- errorNo++;
+ log_err_status(status, "ERROR: in creation of collator: %s\n", myErrorName(status));
+ return;
}
- ucol_close(target);
- /* commented out since safeClone uses exactly the same technique */
- /*
- sourceRules = ucol_getRules(source, &sourceRulesLen);
- target = ucol_openRules(sourceRules, sourceRulesLen, UCOL_DEFAULT, UCOL_DEFAULT, &parseError, &status);
+ baseKeyLength = ucol_getSortKey(myCollation, testString, UPRV_LENGTHOF(testString), baseKey, 256);
+
+ ucol_setReorderCodes(myCollation, reorderCodes, UPRV_LENGTHOF(reorderCodes), &status);
if(U_FAILURE(status)) {
- log_err("Error instantiating target from rules\n");
- errorNo++;
- return errorNo;
+ log_err_status(status, "ERROR: setting reorder codes: %s\n", myErrorName(status));
+ return;
}
- if(!ucol_equals(source, target)) {
- log_err("Collator different from collator that was created from the same rules\n");
- errorNo++;
+ reorderKeyLength = ucol_getSortKey(myCollation, testString, UPRV_LENGTHOF(testString), reorderKey, 256);
+
+ if (baseKeyLength != reorderKeyLength) {
+ log_err("Key lengths not the same during reordering.\n");
+ return;
}
- ucol_close(target);
- */
- }
- return errorNo;
+
+ for (i = 1; i < baseKeyLength; i++) {
+ if (baseKey[i] != reorderKey[i]) {
+ log_err("Collation key bytes not the same at position %d.\n", i);
+ return;
+ }
+ }
+ ucol_close(myCollation);
}
+/*
+ * Test reordering API.
+ */
+static void TestReorderingAPI(void)
+{
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *myCollation;
+ int32_t reorderCodes[3] = {USCRIPT_GREEK, USCRIPT_HAN, UCOL_REORDER_CODE_PUNCTUATION};
+ int32_t duplicateReorderCodes[] = {USCRIPT_HIRAGANA, USCRIPT_GREEK, UCOL_REORDER_CODE_CURRENCY, USCRIPT_KATAKANA};
+ int32_t reorderCodesStartingWithDefault[] = {UCOL_REORDER_CODE_DEFAULT, USCRIPT_GREEK, USCRIPT_HAN, UCOL_REORDER_CODE_PUNCTUATION};
+ int32_t reorderCodeNone = UCOL_REORDER_CODE_NONE;
+ UCollationResult collResult;
+ int32_t retrievedReorderCodesLength;
+ int32_t retrievedReorderCodes[10];
+ UChar greekString[] = { 0x03b1 };
+ UChar punctuationString[] = { 0x203e };
+ int loopIndex;
+
+ log_verbose("Testing non-lead bytes in a sort key with and without reordering\n");
+
+ /* build collator tertiary */
+ myCollation = ucol_open("", &status);
+ ucol_setStrength(myCollation, UCOL_TERTIARY);
+ if(U_FAILURE(status)) {
+ log_err_status(status, "ERROR: in creation of collator: %s\n", myErrorName(status));
+ return;
+ }
-static void TestEquals(void) {
- /* ucol_equals is not currently a public API. There is a chance that it will become
- * something like this, but currently it is only used by RuleBasedCollator::operator==
- */
- /* test whether the two collators instantiated from the same locale are equal */
- UErrorCode status = U_ZERO_ERROR;
- UParseError parseError;
- int32_t noOfLoc = uloc_countAvailable();
- const char *locName = NULL;
- UCollator *source = NULL, *target = NULL;
- int32_t i = 0;
-
- const char* rules[] = {
- "&l < lj <<< Lj <<< LJ",
- "&n < nj <<< Nj <<< NJ",
- "&ae <<< \\u00e4",
- "&AE <<< \\u00c4"
- };
- /*
- const char* badRules[] = {
- "&l <<< Lj",
- "&n < nj <<< nJ <<< NJ",
- "&a <<< \\u00e4",
- "&AE <<< \\u00c4 <<< x"
- };
- */
-
- UChar sourceRules[1024], targetRules[1024];
- int32_t sourceRulesSize = 0, targetRulesSize = 0;
- int32_t rulesSize = sizeof(rules)/sizeof(rules[0]);
+ /* set the reorderding */
+ ucol_setReorderCodes(myCollation, reorderCodes, UPRV_LENGTHOF(reorderCodes), &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: setting reorder codes: %s\n", myErrorName(status));
+ return;
+ }
+
+ /* get the reordering */
+ retrievedReorderCodesLength = ucol_getReorderCodes(myCollation, NULL, 0, &status);
+ if (status != U_BUFFER_OVERFLOW_ERROR) {
+ log_err_status(status, "ERROR: getting error codes should have returned U_BUFFER_OVERFLOW_ERROR : %s\n", myErrorName(status));
+ return;
+ }
+ status = U_ZERO_ERROR;
+ if (retrievedReorderCodesLength != UPRV_LENGTHOF(reorderCodes)) {
+ log_err_status(status, "ERROR: retrieved reorder codes length was %d but should have been %d\n", retrievedReorderCodesLength, UPRV_LENGTHOF(reorderCodes));
+ return;
+ }
+ /* now let's really get it */
+ retrievedReorderCodesLength = ucol_getReorderCodes(myCollation, retrievedReorderCodes, UPRV_LENGTHOF(retrievedReorderCodes), &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: getting reorder codes: %s\n", myErrorName(status));
+ return;
+ }
+ if (retrievedReorderCodesLength != UPRV_LENGTHOF(reorderCodes)) {
+ log_err_status(status, "ERROR: retrieved reorder codes length was %d but should have been %d\n", retrievedReorderCodesLength, UPRV_LENGTHOF(reorderCodes));
+ return;
+ }
+ for (loopIndex = 0; loopIndex < retrievedReorderCodesLength; loopIndex++) {
+ if (retrievedReorderCodes[loopIndex] != reorderCodes[loopIndex]) {
+ log_err_status(status, "ERROR: retrieved reorder code doesn't match set reorder code at index %d\n", loopIndex);
+ return;
+ }
+ }
+ collResult = ucol_strcoll(myCollation, greekString, UPRV_LENGTHOF(greekString), punctuationString, UPRV_LENGTHOF(punctuationString));
+ if (collResult != UCOL_LESS) {
+ log_err_status(status, "ERROR: collation result should have been UCOL_LESS\n");
+ return;
+ }
+
+ /* clear the reordering */
+ ucol_setReorderCodes(myCollation, NULL, 0, &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: setting reorder codes to NULL: %s\n", myErrorName(status));
+ return;
+ }
- for(i = 0; i < rulesSize; i++) {
- sourceRulesSize += u_unescape(rules[i], sourceRules+sourceRulesSize, 1024 - sourceRulesSize);
- targetRulesSize += u_unescape(rules[rulesSize-i-1], targetRules+targetRulesSize, 1024 - targetRulesSize);
- }
+ /* get the reordering again */
+ retrievedReorderCodesLength = ucol_getReorderCodes(myCollation, NULL, 0, &status);
+ if (retrievedReorderCodesLength != 0) {
+ log_err_status(status, "ERROR: retrieved reorder codes length was %d but should have been %d\n", retrievedReorderCodesLength, 0);
+ return;
+ }
- source = ucol_openRules(sourceRules, sourceRulesSize, UCOL_DEFAULT, UCOL_DEFAULT, &parseError, &status);
- if(status == U_FILE_ACCESS_ERROR) {
- log_data_err("Is your data around?\n");
- return;
- } else if(U_FAILURE(status)) {
- log_err("Error opening collator\n");
- return;
- }
- target = ucol_openRules(targetRules, targetRulesSize, UCOL_DEFAULT, UCOL_DEFAULT, &parseError, &status);
- if(!ucol_equals(source, target)) {
- log_err("Equivalent collators not equal!\n");
- }
- ucol_close(source);
- ucol_close(target);
-
- source = ucol_open("root", &status);
- target = ucol_open("root", &status);
- log_verbose("Testing root\n");
- if(!ucol_equals(source, source)) {
- log_err("Same collator not equal\n");
- }
- if(TestEqualsForCollator(locName, source, target)) {
- log_err("Errors for root\n", locName);
- }
- ucol_close(source);
+ collResult = ucol_strcoll(myCollation, greekString, UPRV_LENGTHOF(greekString), punctuationString, UPRV_LENGTHOF(punctuationString));
+ if (collResult != UCOL_GREATER) {
+ log_err_status(status, "ERROR: collation result should have been UCOL_GREATER\n");
+ return;
+ }
- for(i = 0; i<noOfLoc; i++) {
- status = U_ZERO_ERROR;
- locName = uloc_getAvailable(i);
- /*if(hasCollationElements(locName)) {*/
- log_verbose("Testing equality for locale %s\n", locName);
- source = ucol_open(locName, &status);
- target = ucol_open(locName, &status);
- if(TestEqualsForCollator(locName, source, target)) {
- log_err("Errors for locale %s\n", locName);
- }
- ucol_close(source);
- /*}*/
- }
-}
+ /* clear the reordering using [NONE] */
+ ucol_setReorderCodes(myCollation, &reorderCodeNone, 1, &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: setting reorder codes to [NONE]: %s\n", myErrorName(status));
+ return;
+ }
-static void TestJ2726(void) {
- UChar a[2] = { 0x61, 0x00 }; /*"a"*/
- UChar aSpace[3] = { 0x61, 0x20, 0x00 }; /*"a "*/
- UChar spaceA[3] = { 0x20, 0x61, 0x00 }; /*" a"*/
- UErrorCode status = U_ZERO_ERROR;
- UCollator *coll = ucol_open("en", &status);
- ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
- ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_PRIMARY, &status);
- doTest(coll, a, aSpace, UCOL_EQUAL);
- doTest(coll, aSpace, a, UCOL_EQUAL);
- doTest(coll, a, spaceA, UCOL_EQUAL);
- doTest(coll, spaceA, a, UCOL_EQUAL);
- doTest(coll, spaceA, aSpace, UCOL_EQUAL);
- doTest(coll, aSpace, spaceA, UCOL_EQUAL);
- ucol_close(coll);
-}
+ /* get the reordering again */
+ retrievedReorderCodesLength = ucol_getReorderCodes(myCollation, NULL, 0, &status);
+ if (retrievedReorderCodesLength != 0) {
+ log_err_status(status,
+ "ERROR: [NONE] retrieved reorder codes length was %d but should have been 0\n",
+ retrievedReorderCodesLength);
+ return;
+ }
-static void NullRule(void) {
- UChar r[3] = {0};
- UErrorCode status = U_ZERO_ERROR;
- UCollator *coll = ucol_openRules(r, 1, UCOL_DEFAULT, UCOL_DEFAULT, NULL, &status);
- if(U_SUCCESS(status)) {
- log_err("This should have been an error!\n");
- ucol_close(coll);
- } else {
+ /* test for error condition on duplicate reorder codes */
+ ucol_setReorderCodes(myCollation, duplicateReorderCodes, UPRV_LENGTHOF(duplicateReorderCodes), &status);
+ if (!U_FAILURE(status)) {
+ log_err_status(status, "ERROR: setting duplicate reorder codes did not generate a failure\n");
+ return;
+ }
+
status = U_ZERO_ERROR;
- }
- coll = ucol_openRules(r, 0, UCOL_DEFAULT, UCOL_DEFAULT, NULL, &status);
- if(U_FAILURE(status)) {
- log_err("Empty rules should have produced a valid collator\n");
- } else {
- ucol_close(coll);
- }
+ /* test for reorder codes after a reset code */
+ ucol_setReorderCodes(myCollation, reorderCodesStartingWithDefault, UPRV_LENGTHOF(reorderCodesStartingWithDefault), &status);
+ if (!U_FAILURE(status)) {
+ log_err_status(status, "ERROR: reorderd code sequence starting with default and having following codes didn't cause an error\n");
+ return;
+ }
+
+ ucol_close(myCollation);
}
-/**
- * Test for CollationElementIterator previous and next for the whole set of
- * unicode characters with normalization on.
+/*
+ * Test reordering API.
*/
-static void TestNumericCollation(void)
+static void TestReorderingAPIWithRuleCreatedCollator(void)
{
UErrorCode status = U_ZERO_ERROR;
+ UCollator *myCollation;
+ UChar rules[90];
+ static const int32_t rulesReorderCodes[2] = {USCRIPT_HAN, USCRIPT_GREEK};
+ static const int32_t reorderCodes[3] = {USCRIPT_GREEK, USCRIPT_HAN, UCOL_REORDER_CODE_PUNCTUATION};
+ static const int32_t onlyDefault[1] = {UCOL_REORDER_CODE_DEFAULT};
+ UCollationResult collResult;
+ int32_t retrievedReorderCodesLength;
+ int32_t retrievedReorderCodes[10];
+ static const UChar greekString[] = { 0x03b1 };
+ static const UChar punctuationString[] = { 0x203e };
+ static const UChar hanString[] = { 0x65E5, 0x672C };
+ int loopIndex;
+
+ log_verbose("Testing non-lead bytes in a sort key with and without reordering\n");
+
+ /* build collator from rules */
+ u_uastrcpy(rules, "[reorder Hani Grek]");
+ myCollation = ucol_openRules(rules, u_strlen(rules), UCOL_DEFAULT, UCOL_TERTIARY, NULL, &status);
+ if(U_FAILURE(status)) {
+ log_err_status(status, "ERROR: in creation of collator: %s\n", myErrorName(status));
+ return;
+ }
- const static char *basicTestStrings[]={
- "hello1",
- "hello2",
- "hello2002",
- "hello2003",
- "hello123456",
- "hello1234567",
- "hello10000000",
- "hello100000000",
- "hello1000000000",
- "hello10000000000",
- };
-
- const static char *preZeroTestStrings[]={
- "avery10000",
- "avery010000",
- "avery0010000",
- "avery00010000",
- "avery000010000",
- "avery0000010000",
- "avery00000010000",
- "avery000000010000",
- };
+ /* get the reordering */
+ retrievedReorderCodesLength = ucol_getReorderCodes(myCollation, retrievedReorderCodes, UPRV_LENGTHOF(retrievedReorderCodes), &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: getting reorder codes: %s\n", myErrorName(status));
+ return;
+ }
+ if (retrievedReorderCodesLength != UPRV_LENGTHOF(rulesReorderCodes)) {
+ log_err_status(status, "ERROR: retrieved reorder codes length was %d but should have been %d\n", retrievedReorderCodesLength, UPRV_LENGTHOF(rulesReorderCodes));
+ return;
+ }
+ for (loopIndex = 0; loopIndex < retrievedReorderCodesLength; loopIndex++) {
+ if (retrievedReorderCodes[loopIndex] != rulesReorderCodes[loopIndex]) {
+ log_err_status(status, "ERROR: retrieved reorder code doesn't match set reorder code at index %d\n", loopIndex);
+ return;
+ }
+ }
+ collResult = ucol_strcoll(myCollation, greekString, UPRV_LENGTHOF(greekString), hanString, UPRV_LENGTHOF(hanString));
+ if (collResult != UCOL_GREATER) {
+ log_err_status(status, "ERROR: collation result should have been UCOL_GREATER\n");
+ return;
+ }
- const static char *thirtyTwoBitNumericStrings[]={
- "avery42949672960",
- "avery42949672961",
- "avery42949672962",
- "avery429496729610"
- };
+ /* set the reordering */
+ ucol_setReorderCodes(myCollation, reorderCodes, UPRV_LENGTHOF(reorderCodes), &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: setting reorder codes: %s\n", myErrorName(status));
+ return;
+ }
- const static char *supplementaryDigits[] = {
- "\\uD835\\uDFCE", /* 0 */
- "\\uD835\\uDFCF", /* 1 */
- "\\uD835\\uDFD0", /* 2 */
- "\\uD835\\uDFD1", /* 3 */
- "\\uD835\\uDFCF\\uD835\\uDFCE", /* 10 */
- "\\uD835\\uDFCF\\uD835\\uDFCF", /* 11 */
- "\\uD835\\uDFCF\\uD835\\uDFD0", /* 12 */
- "\\uD835\\uDFD0\\uD835\\uDFCE", /* 20 */
- "\\uD835\\uDFD0\\uD835\\uDFCF", /* 21 */
- "\\uD835\\uDFD0\\uD835\\uDFD0" /* 22 */
- };
+ /* get the reordering */
+ retrievedReorderCodesLength = ucol_getReorderCodes(myCollation, NULL, 0, &status);
+ if (status != U_BUFFER_OVERFLOW_ERROR) {
+ log_err_status(status, "ERROR: getting error codes should have returned U_BUFFER_OVERFLOW_ERROR : %s\n", myErrorName(status));
+ return;
+ }
+ status = U_ZERO_ERROR;
+ if (retrievedReorderCodesLength != UPRV_LENGTHOF(reorderCodes)) {
+ log_err_status(status, "ERROR: retrieved reorder codes length was %d but should have been %d\n", retrievedReorderCodesLength, UPRV_LENGTHOF(reorderCodes));
+ return;
+ }
+ /* now let's really get it */
+ retrievedReorderCodesLength = ucol_getReorderCodes(myCollation, retrievedReorderCodes, UPRV_LENGTHOF(retrievedReorderCodes), &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: getting reorder codes: %s\n", myErrorName(status));
+ return;
+ }
+ if (retrievedReorderCodesLength != UPRV_LENGTHOF(reorderCodes)) {
+ log_err_status(status, "ERROR: retrieved reorder codes length was %d but should have been %d\n", retrievedReorderCodesLength, UPRV_LENGTHOF(reorderCodes));
+ return;
+ }
+ for (loopIndex = 0; loopIndex < retrievedReorderCodesLength; loopIndex++) {
+ if (retrievedReorderCodes[loopIndex] != reorderCodes[loopIndex]) {
+ log_err_status(status, "ERROR: retrieved reorder code doesn't match set reorder code at index %d\n", loopIndex);
+ return;
+ }
+ }
+ collResult = ucol_strcoll(myCollation, greekString, UPRV_LENGTHOF(greekString), punctuationString, UPRV_LENGTHOF(punctuationString));
+ if (collResult != UCOL_LESS) {
+ log_err_status(status, "ERROR: collation result should have been UCOL_LESS\n");
+ return;
+ }
- const static char *foreignDigits[] = {
- "\\u0661",
- "\\u0662",
- "\\u0663",
- "\\u0661\\u0660",
- "\\u0661\\u0662",
- "\\u0661\\u0663",
- "\\u0662\\u0660",
- "\\u0662\\u0662",
- "\\u0662\\u0663",
- "\\u0663\\u0660",
- "\\u0663\\u0662",
- "\\u0663\\u0663"
- };
+ /* clear the reordering */
+ ucol_setReorderCodes(myCollation, NULL, 0, &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: setting reorder codes to NULL: %s\n", myErrorName(status));
+ return;
+ }
- const static char *evenZeroes[] = {
- "2000",
- "2001",
- "2002",
- "2003"
- };
+ /* get the reordering again */
+ retrievedReorderCodesLength = ucol_getReorderCodes(myCollation, NULL, 0, &status);
+ if (retrievedReorderCodesLength != 0) {
+ log_err_status(status, "ERROR: retrieved reorder codes length was %d but should have been %d\n", retrievedReorderCodesLength, 0);
+ return;
+ }
- UColAttribute att = UCOL_NUMERIC_COLLATION;
- UColAttributeValue val = UCOL_ON;
+ collResult = ucol_strcoll(myCollation, greekString, UPRV_LENGTHOF(greekString), punctuationString, UPRV_LENGTHOF(punctuationString));
+ if (collResult != UCOL_GREATER) {
+ log_err_status(status, "ERROR: collation result should have been UCOL_GREATER\n");
+ return;
+ }
- /* Open our collator. */
- UCollator* coll = ucol_open("root", &status);
- if (U_FAILURE(status)){
- log_err("ERROR: in using ucol_open()\n %s\n",
- myErrorName(status));
+ /* reset the reordering */
+ ucol_setReorderCodes(myCollation, onlyDefault, 1, &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: setting reorder codes to {default}: %s\n", myErrorName(status));
return;
}
- genericLocaleStarterWithOptions("root", basicTestStrings, sizeof(basicTestStrings)/sizeof(basicTestStrings[0]), &att, &val, 1);
- genericLocaleStarterWithOptions("root", thirtyTwoBitNumericStrings, sizeof(thirtyTwoBitNumericStrings)/sizeof(thirtyTwoBitNumericStrings[0]), &att, &val, 1);
- genericLocaleStarterWithOptions("en_US", foreignDigits, sizeof(foreignDigits)/sizeof(foreignDigits[0]), &att, &val, 1);
- genericLocaleStarterWithOptions("root", supplementaryDigits, sizeof(supplementaryDigits)/sizeof(supplementaryDigits[0]), &att, &val, 1);
- genericLocaleStarterWithOptions("root", evenZeroes, sizeof(evenZeroes)/sizeof(evenZeroes[0]), &att, &val, 1);
-
- /* Setting up our collator to do digits. */
- ucol_setAttribute(coll, UCOL_NUMERIC_COLLATION, UCOL_ON, &status);
- if (U_FAILURE(status)){
- log_err("ERROR: in setting UCOL_NUMERIC_COLLATION as an attribute\n %s\n",
- myErrorName(status));
+ retrievedReorderCodesLength = ucol_getReorderCodes(myCollation, retrievedReorderCodes, UPRV_LENGTHOF(retrievedReorderCodes), &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: getting reorder codes: %s\n", myErrorName(status));
+ return;
+ }
+ if (retrievedReorderCodesLength != UPRV_LENGTHOF(rulesReorderCodes)) {
+ log_err_status(status, "ERROR: retrieved reorder codes length was %d but should have been %d\n", retrievedReorderCodesLength, UPRV_LENGTHOF(rulesReorderCodes));
return;
}
+ for (loopIndex = 0; loopIndex < retrievedReorderCodesLength; loopIndex++) {
+ if (retrievedReorderCodes[loopIndex] != rulesReorderCodes[loopIndex]) {
+ log_err_status(status, "ERROR: retrieved reorder code doesn't match set reorder code at index %d\n", loopIndex);
+ return;
+ }
+ }
- /*
- Testing that prepended zeroes still yield the correct collation behavior.
- We expect that every element in our strings array will be equal.
- */
- genericOrderingTestWithResult(coll, preZeroTestStrings, sizeof(preZeroTestStrings)/sizeof(preZeroTestStrings[0]), UCOL_EQUAL);
+ ucol_close(myCollation);
+}
- ucol_close(coll);
+static UBool containsExpectedScript(const int32_t scripts[], int32_t length, int32_t expectedScript) {
+ int32_t i;
+ for (i = 0; i < length; ++i) {
+ if (expectedScript == scripts[i]) { return TRUE; }
+ }
+ return FALSE;
}
-static void TestTibetanConformance(void)
-{
- const char* test[] = {
- "\\u0FB2\\u0591\\u0F71\\u0061",
- "\\u0FB2\\u0F71\\u0061"
+static void TestEquivalentReorderingScripts(void) {
+ // Beginning with ICU 55, collation reordering moves single scripts
+ // rather than groups of scripts,
+ // except where scripts share a range and sort primary-equal.
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t equivalentScripts[100];
+ int32_t length;
+ int i;
+ int32_t prevScript;
+ /* These scripts are expected to be equivalent. */
+ static const int32_t expectedScripts[] = {
+ USCRIPT_HIRAGANA,
+ USCRIPT_KATAKANA,
+ USCRIPT_KATAKANA_OR_HIRAGANA
};
- UErrorCode status = U_ZERO_ERROR;
- UCollator *coll = ucol_open("", &status);
- UChar source[100];
- UChar target[100];
- int result;
- ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
- if (U_SUCCESS(status)) {
- u_unescape(test[0], source, 100);
- u_unescape(test[1], target, 100);
- doTest(coll, source, target, UCOL_EQUAL);
- result = ucol_strcoll(coll, source, -1, target, -1);
- log_verbose("result %d\n", result);
- if (UCOL_EQUAL != result) {
- log_err("Tibetan comparison error\n");
- }
+ equivalentScripts[0] = 0;
+ length = ucol_getEquivalentReorderCodes(
+ USCRIPT_GOTHIC, equivalentScripts, UPRV_LENGTHOF(equivalentScripts), &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR/Gothic: retrieving equivalent reorder codes: %s\n", myErrorName(status));
+ return;
+ }
+ if (length != 1 || equivalentScripts[0] != USCRIPT_GOTHIC) {
+ log_err("ERROR/Gothic: retrieved equivalent scripts wrong: "
+ "length expected 1, was = %d; expected [%d] was [%d]\n",
+ length, USCRIPT_GOTHIC, equivalentScripts[0]);
}
- ucol_close(coll);
- genericLocaleStarterWithResult("", test, 2, UCOL_EQUAL);
-}
+ length = ucol_getEquivalentReorderCodes(
+ USCRIPT_HIRAGANA, equivalentScripts, UPRV_LENGTHOF(equivalentScripts), &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR/Hiragana: retrieving equivalent reorder codes: %s\n", myErrorName(status));
+ return;
+ }
+ if (length != UPRV_LENGTHOF(expectedScripts)) {
+ log_err("ERROR/Hiragana: retrieved equivalent script length wrong: "
+ "expected %d, was = %d\n",
+ UPRV_LENGTHOF(expectedScripts), length);
+ }
+ prevScript = -1;
+ for (i = 0; i < length; ++i) {
+ int32_t script = equivalentScripts[i];
+ if (script <= prevScript) {
+ log_err("ERROR/Hiragana: equivalent scripts out of order at index %d\n", i);
+ }
+ prevScript = script;
+ }
+ for (i = 0; i < UPRV_LENGTHOF(expectedScripts); i++) {
+ if (!containsExpectedScript(equivalentScripts, length, expectedScripts[i])) {
+ log_err("ERROR/Hiragana: equivalent scripts do not contain %d\n",
+ expectedScripts[i]);
+ }
+ }
-static void TestPinyinProblem(void) {
- static const char *test[] = { "\\u4E56\\u4E56\\u7761", "\\u4E56\\u5B69\\u5B50" };
- genericLocaleStarter("zh__PINYIN", test, sizeof(test)/sizeof(test[0]));
-}
+ length = ucol_getEquivalentReorderCodes(
+ USCRIPT_KATAKANA, equivalentScripts, UPRV_LENGTHOF(equivalentScripts), &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR/Katakana: retrieving equivalent reorder codes: %s\n", myErrorName(status));
+ return;
+ }
+ if (length != UPRV_LENGTHOF(expectedScripts)) {
+ log_err("ERROR/Katakana: retrieved equivalent script length wrong: "
+ "expected %d, was = %d\n",
+ UPRV_LENGTHOF(expectedScripts), length);
+ }
+ for (i = 0; i < UPRV_LENGTHOF(expectedScripts); i++) {
+ if (!containsExpectedScript(equivalentScripts, length, expectedScripts[i])) {
+ log_err("ERROR/Katakana: equivalent scripts do not contain %d\n",
+ expectedScripts[i]);
+ }
+ }
-#define TST_UCOL_MAX_INPUT 0x220001
-#define topByte 0xFF000000;
-#define bottomByte 0xFF;
-#define fourBytes 0xFFFFFFFF;
+ length = ucol_getEquivalentReorderCodes(
+ USCRIPT_KATAKANA_OR_HIRAGANA, equivalentScripts, UPRV_LENGTHOF(equivalentScripts), &status);
+ if (U_FAILURE(status) || length != UPRV_LENGTHOF(expectedScripts)) {
+ log_err("ERROR/Hrkt: retrieved equivalent script length wrong: "
+ "expected %d, was = %d\n",
+ UPRV_LENGTHOF(expectedScripts), length);
+ }
+ length = ucol_getEquivalentReorderCodes(
+ USCRIPT_HAN, equivalentScripts, UPRV_LENGTHOF(equivalentScripts), &status);
+ if (U_FAILURE(status) || length != 3) {
+ log_err("ERROR/Hani: retrieved equivalent script length wrong: "
+ "expected 3, was = %d\n", length);
+ }
+ length = ucol_getEquivalentReorderCodes(
+ USCRIPT_SIMPLIFIED_HAN, equivalentScripts, UPRV_LENGTHOF(equivalentScripts), &status);
+ if (U_FAILURE(status) || length != 3) {
+ log_err("ERROR/Hans: retrieved equivalent script length wrong: "
+ "expected 3, was = %d\n", length);
+ }
+ length = ucol_getEquivalentReorderCodes(
+ USCRIPT_TRADITIONAL_HAN, equivalentScripts, UPRV_LENGTHOF(equivalentScripts), &status);
+ if (U_FAILURE(status) || length != 3) {
+ log_err("ERROR/Hant: retrieved equivalent script length wrong: "
+ "expected 3, was = %d\n", length);
+ }
-static void showImplicit(UChar32 i) {
- if (i >= 0 && i <= TST_UCOL_MAX_INPUT) {
- log_verbose("%08X\t%08X\n", i, uprv_uca_getImplicitFromRaw(i));
+ length = ucol_getEquivalentReorderCodes(
+ USCRIPT_MEROITIC_CURSIVE, equivalentScripts, UPRV_LENGTHOF(equivalentScripts), &status);
+ if (U_FAILURE(status) || length != 2) {
+ log_err("ERROR/Merc: retrieved equivalent script length wrong: "
+ "expected 2, was = %d\n", length);
+ }
+ length = ucol_getEquivalentReorderCodes(
+ USCRIPT_MEROITIC_HIEROGLYPHS, equivalentScripts, UPRV_LENGTHOF(equivalentScripts), &status);
+ if (U_FAILURE(status) || length != 2) {
+ log_err("ERROR/Mero: retrieved equivalent script length wrong: "
+ "expected 2, was = %d\n", length);
}
}
-static void TestImplicitGeneration(void) {
+static void TestReorderingAcrossCloning(void)
+{
UErrorCode status = U_ZERO_ERROR;
- UChar32 last = 0;
- UChar32 current;
- UChar32 i = 0, j = 0;
- UChar32 roundtrip = 0;
- UChar32 lastBottom = 0;
- UChar32 currentBottom = 0;
- UChar32 lastTop = 0;
- UChar32 currentTop = 0;
-
- UCollator *coll = ucol_open("root", &status);
+ UCollator *myCollation;
+ int32_t reorderCodes[3] = {USCRIPT_GREEK, USCRIPT_HAN, UCOL_REORDER_CODE_PUNCTUATION};
+ UCollator *clonedCollation;
+ int32_t retrievedReorderCodesLength;
+ int32_t retrievedReorderCodes[10];
+ int loopIndex;
+
+ log_verbose("Testing non-lead bytes in a sort key with and without reordering\n");
+
+ /* build collator tertiary */
+ myCollation = ucol_open("", &status);
+ ucol_setStrength(myCollation, UCOL_TERTIARY);
if(U_FAILURE(status)) {
- log_err("Couldn't open UCA\n");
+ log_err_status(status, "ERROR: in creation of collator: %s\n", myErrorName(status));
return;
}
- uprv_uca_getRawFromImplicit(0xE20303E7);
-
- for (i = 0; i <= TST_UCOL_MAX_INPUT; ++i) {
- current = uprv_uca_getImplicitFromRaw(i) & fourBytes;
-
- /* check that it round-trips AND that all intervening ones are illegal*/
- roundtrip = uprv_uca_getRawFromImplicit(current);
- if (roundtrip != i) {
- log_err("No roundtrip %08X\n", i);
- }
- if (last != 0) {
- for (j = last + 1; j < current; ++j) {
- roundtrip = uprv_uca_getRawFromImplicit(j);
- /* raise an error if it *doesn't* find an error*/
- if (roundtrip != -1) {
- log_err("Fails to recognize illegal %08X\n", j);
- }
- }
- }
- /* now do other consistency checks*/
- lastBottom = last & bottomByte;
- currentBottom = current & bottomByte;
- lastTop = last & topByte;
- currentTop = current & topByte;
-
- /* print out some values for spot-checking*/
- if (lastTop != currentTop || i == 0x10000 || i == 0x110000) {
- showImplicit(i-3);
- showImplicit(i-2);
- showImplicit(i-1);
- showImplicit(i);
- showImplicit(i+1);
- showImplicit(i+2);
- }
- last = current;
-
- if(uprv_uca_getCodePointFromRaw(uprv_uca_getRawFromCodePoint(i)) != i) {
- log_err("No raw <-> code point roundtrip for 0x%08X\n", i);
+ /* set the reorderding */
+ ucol_setReorderCodes(myCollation, reorderCodes, UPRV_LENGTHOF(reorderCodes), &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: setting reorder codes: %s\n", myErrorName(status));
+ return;
+ }
+
+ /* clone the collator */
+ clonedCollation = ucol_safeClone(myCollation, NULL, NULL, &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: cloning collator: %s\n", myErrorName(status));
+ return;
+ }
+
+ /* get the reordering */
+ retrievedReorderCodesLength = ucol_getReorderCodes(clonedCollation, retrievedReorderCodes, UPRV_LENGTHOF(retrievedReorderCodes), &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: getting reorder codes: %s\n", myErrorName(status));
+ return;
+ }
+ if (retrievedReorderCodesLength != UPRV_LENGTHOF(reorderCodes)) {
+ log_err_status(status, "ERROR: retrieved reorder codes length was %d but should have been %d\n", retrievedReorderCodesLength, UPRV_LENGTHOF(reorderCodes));
+ return;
+ }
+ for (loopIndex = 0; loopIndex < retrievedReorderCodesLength; loopIndex++) {
+ if (retrievedReorderCodes[loopIndex] != reorderCodes[loopIndex]) {
+ log_err_status(status, "ERROR: retrieved reorder code doesn't match set reorder code at index %d\n", loopIndex);
+ return;
}
}
- showImplicit(TST_UCOL_MAX_INPUT-2);
- showImplicit(TST_UCOL_MAX_INPUT-1);
- showImplicit(TST_UCOL_MAX_INPUT);
- ucol_close(coll);
+
+ /*uprv_free(buffer);*/
+ ucol_close(myCollation);
+ ucol_close(clonedCollation);
}
-/**
- * Iterate through the given iterator, checking to see that all the strings
- * in the expected array are present.
- * @param expected array of strings we expect to see, or NULL
- * @param expectedCount number of elements of expected, or 0
+/*
+ * Utility function to test one collation reordering test case set.
+ * @param testcases Array of test cases.
+ * @param n_testcases Size of the array testcases.
+ * @param reorderTokens Array of reordering codes.
+ * @param reorderTokensLen Size of the array reorderTokens.
*/
-static int32_t checkUEnumeration(const char* msg,
- UEnumeration* iter,
- const char** expected,
- int32_t expectedCount) {
- UErrorCode ec = U_ZERO_ERROR;
- int32_t i = 0, n, j, bit;
- int32_t seenMask = 0;
+static void doTestOneReorderingAPITestCase(const OneTestCase testCases[], uint32_t testCasesLen, const int32_t reorderTokens[], int32_t reorderTokensLen)
+{
+ uint32_t testCaseNum;
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *myCollation;
- U_ASSERT(expectedCount >= 0 && expectedCount < 31); /* [sic] 31 not 32 */
- n = uenum_count(iter, &ec);
- if (!assertSuccess("count", &ec)) return -1;
- log_verbose("%s = [", msg);
- for (;; ++i) {
- const char* s = uenum_next(iter, NULL, &ec);
- if (!assertSuccess("snext", &ec) || s == NULL) break;
- if (i != 0) log_verbose(",");
- log_verbose("%s", s);
- /* check expected list */
- for (j=0, bit=1; j<expectedCount; ++j, bit<<=1) {
- if ((seenMask&bit) == 0 &&
- uprv_strcmp(s, expected[j]) == 0) {
- seenMask |= bit;
- break;
- }
- }
+ myCollation = ucol_open("", &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: in creation of collator: %s\n", myErrorName(status));
+ return;
}
- log_verbose("] (%d)\n", i);
- assertTrue("count verified", i==n);
- /* did we see all expected strings? */
- for (j=0, bit=1; j<expectedCount; ++j, bit<<=1) {
- if ((seenMask&bit)!=0) {
- log_verbose("Ok: \"%s\" seen\n", expected[j]);
- } else {
- log_err("FAIL: \"%s\" not seen\n", expected[j]);
- }
+ ucol_setReorderCodes(myCollation, reorderTokens, reorderTokensLen, &status);
+ if(U_FAILURE(status)) {
+ log_err_status(status, "ERROR: while setting script order: %s\n", myErrorName(status));
+ return;
}
- return n;
+
+ for (testCaseNum = 0; testCaseNum < testCasesLen; ++testCaseNum) {
+ doTest(myCollation,
+ testCases[testCaseNum].source,
+ testCases[testCaseNum].target,
+ testCases[testCaseNum].result
+ );
+ }
+ ucol_close(myCollation);
}
-/**
- * Test new API added for separate collation tree.
- */
-static void TestSeparateTrees(void) {
- UErrorCode ec = U_ZERO_ERROR;
- UEnumeration *e = NULL;
- int32_t n = -1;
- UBool isAvailable;
- char loc[256];
+static void TestGreekFirstReorder(void)
+{
+ const char* strRules[] = {
+ "[reorder Grek]"
+ };
- static const char* AVAIL[] = { "en", "de" };
+ const int32_t apiRules[] = {
+ USCRIPT_GREEK
+ };
+
+ const static OneTestCase privateUseCharacterStrings[] = {
+ { {0x0391}, {0x0391}, UCOL_EQUAL },
+ { {0x0041}, {0x0391}, UCOL_GREATER },
+ { {0x03B1, 0x0041}, {0x03B1, 0x0391}, UCOL_GREATER },
+ { {0x0060}, {0x0391}, UCOL_LESS },
+ { {0x0391}, {0xe2dc}, UCOL_LESS },
+ { {0x0391}, {0x0060}, UCOL_GREATER },
+ };
- static const char* KW[] = { "collation" };
+ /* Test rules creation */
+ doTestOneTestCase(privateUseCharacterStrings, UPRV_LENGTHOF(privateUseCharacterStrings), strRules, UPRV_LENGTHOF(strRules));
- static const char* KWVAL[] = { "phonebook", "stroke" };
+ /* Test collation reordering API */
+ doTestOneReorderingAPITestCase(privateUseCharacterStrings, UPRV_LENGTHOF(privateUseCharacterStrings), apiRules, UPRV_LENGTHOF(apiRules));
+}
-#if !UCONFIG_NO_SERVICE
- e = ucol_openAvailableLocales(&ec);
- assertSuccess("ucol_openAvailableLocales", &ec);
- assertTrue("ucol_openAvailableLocales!=0", e!=0);
- n = checkUEnumeration("ucol_openAvailableLocales", e, AVAIL, LEN(AVAIL));
- /* Don't need to check n because we check list */
- uenum_close(e);
-#endif
+static void TestGreekLastReorder(void)
+{
+ const char* strRules[] = {
+ "[reorder Zzzz Grek]"
+ };
- e = ucol_getKeywords(&ec);
- assertSuccess("ucol_getKeywords", &ec);
- assertTrue("ucol_getKeywords!=0", e!=0);
- n = checkUEnumeration("ucol_getKeywords", e, KW, LEN(KW));
- /* Don't need to check n because we check list */
- uenum_close(e);
+ const int32_t apiRules[] = {
+ USCRIPT_UNKNOWN, USCRIPT_GREEK
+ };
+
+ const static OneTestCase privateUseCharacterStrings[] = {
+ { {0x0391}, {0x0391}, UCOL_EQUAL },
+ { {0x0041}, {0x0391}, UCOL_LESS },
+ { {0x03B1, 0x0041}, {0x03B1, 0x0391}, UCOL_LESS },
+ { {0x0060}, {0x0391}, UCOL_LESS },
+ { {0x0391}, {0xe2dc}, UCOL_GREATER },
+ };
+
+ /* Test rules creation */
+ doTestOneTestCase(privateUseCharacterStrings, UPRV_LENGTHOF(privateUseCharacterStrings), strRules, UPRV_LENGTHOF(strRules));
- e = ucol_getKeywordValues(KW[0], &ec);
- assertSuccess("ucol_getKeywordValues", &ec);
- assertTrue("ucol_getKeywordValues!=0", e!=0);
- n = checkUEnumeration("ucol_getKeywordValues", e, KWVAL, LEN(KWVAL));
- /* Don't need to check n because we check list */
- uenum_close(e);
+ /* Test collation reordering API */
+ doTestOneReorderingAPITestCase(privateUseCharacterStrings, UPRV_LENGTHOF(privateUseCharacterStrings), apiRules, UPRV_LENGTHOF(apiRules));
+}
- /* Try setting a warning before calling ucol_getKeywordValues */
- ec = U_USING_FALLBACK_WARNING;
- e = ucol_getKeywordValues(KW[0], &ec);
- assertSuccess("ucol_getKeywordValues [with warning code set]", &ec);
- assertTrue("ucol_getKeywordValues!=0 [with warning code set]", e!=0);
- n = checkUEnumeration("ucol_getKeywordValues [with warning code set]", e, KWVAL, LEN(KWVAL));
- /* Don't need to check n because we check list */
- uenum_close(e);
+static void TestNonScriptReorder(void)
+{
+ const char* strRules[] = {
+ "[reorder Grek Symbol DIGIT Latn Punct space Zzzz cURRENCy]"
+ };
- /*
-U_DRAFT int32_t U_EXPORT2
-ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,
- const char* locale, UBool* isAvailable,
- UErrorCode* status);
+ const int32_t apiRules[] = {
+ USCRIPT_GREEK, UCOL_REORDER_CODE_SYMBOL, UCOL_REORDER_CODE_DIGIT, USCRIPT_LATIN,
+ UCOL_REORDER_CODE_PUNCTUATION, UCOL_REORDER_CODE_SPACE, USCRIPT_UNKNOWN,
+ UCOL_REORDER_CODE_CURRENCY
+ };
+
+ const static OneTestCase privateUseCharacterStrings[] = {
+ { {0x0391}, {0x0041}, UCOL_LESS },
+ { {0x0041}, {0x0391}, UCOL_GREATER },
+ { {0x0060}, {0x0041}, UCOL_LESS },
+ { {0x0060}, {0x0391}, UCOL_GREATER },
+ { {0x0024}, {0x0041}, UCOL_GREATER },
+ };
+
+ /* Test rules creation */
+ doTestOneTestCase(privateUseCharacterStrings, UPRV_LENGTHOF(privateUseCharacterStrings), strRules, UPRV_LENGTHOF(strRules));
+
+ /* Test collation reordering API */
+ doTestOneReorderingAPITestCase(privateUseCharacterStrings, UPRV_LENGTHOF(privateUseCharacterStrings), apiRules, UPRV_LENGTHOF(apiRules));
}
-*/
- n = ucol_getFunctionalEquivalent(loc, sizeof(loc), "collation", "fr",
- &isAvailable, &ec);
- assertSuccess("getFunctionalEquivalent", &ec);
- assertEquals("getFunctionalEquivalent(fr)", "fr", loc);
- assertTrue("getFunctionalEquivalent(fr).isAvailable==TRUE",
- isAvailable == TRUE);
- n = ucol_getFunctionalEquivalent(loc, sizeof(loc), "collation", "fr_FR",
- &isAvailable, &ec);
- assertSuccess("getFunctionalEquivalent", &ec);
- assertEquals("getFunctionalEquivalent(fr_FR)", "fr", loc);
- assertTrue("getFunctionalEquivalent(fr_FR).isAvailable==TRUE",
- isAvailable == TRUE);
+static void TestHaniReorder(void)
+{
+ const char* strRules[] = {
+ "[reorder Hani]"
+ };
+ const int32_t apiRules[] = {
+ USCRIPT_HAN
+ };
+
+ const static OneTestCase privateUseCharacterStrings[] = {
+ { {0x4e00}, {0x0041}, UCOL_LESS },
+ { {0x4e00}, {0x0060}, UCOL_GREATER },
+ { {0xD86D, 0xDF40}, {0x0041}, UCOL_LESS },
+ { {0xD86D, 0xDF40}, {0x0060}, UCOL_GREATER },
+ { {0x4e00}, {0xD86D, 0xDF40}, UCOL_LESS },
+ { {0xfa27}, {0x0041}, UCOL_LESS },
+ { {0xD869, 0xDF00}, {0x0041}, UCOL_LESS },
+ };
+
+ /* Test rules creation */
+ doTestOneTestCase(privateUseCharacterStrings, UPRV_LENGTHOF(privateUseCharacterStrings), strRules, UPRV_LENGTHOF(strRules));
+
+ /* Test collation reordering API */
+ doTestOneReorderingAPITestCase(privateUseCharacterStrings, UPRV_LENGTHOF(privateUseCharacterStrings), apiRules, UPRV_LENGTHOF(apiRules));
}
-/* supercedes TestJ784 */
-static void TestBeforePinyin(void) {
- const static char rules[] = {
- "&[before 2]A<<\\u0101<<<\\u0100<<\\u00E1<<<\\u00C1<<\\u01CE<<<\\u01CD<<\\u00E0<<<\\u00C0"
- "&[before 2]e<<\\u0113<<<\\u0112<<\\u00E9<<<\\u00C9<<\\u011B<<<\\u011A<<\\u00E8<<<\\u00C8"
- "&[before 2]i<<\\u012B<<<\\u012A<<\\u00ED<<<\\u00CD<<\\u01D0<<<\\u01CF<<\\u00EC<<<\\u00CC"
- "&[before 2]o<<\\u014D<<<\\u014C<<\\u00F3<<<\\u00D3<<\\u01D2<<<\\u01D1<<\\u00F2<<<\\u00D2"
- "&[before 2]u<<\\u016B<<<\\u016A<<\\u00FA<<<\\u00DA<<\\u01D4<<<\\u01D3<<\\u00F9<<<\\u00D9"
- "&U<<\\u01D6<<<\\u01D5<<\\u01D8<<<\\u01D7<<\\u01DA<<<\\u01D9<<\\u01DC<<<\\u01DB<<\\u00FC"
+static void TestHaniReorderWithOtherRules(void)
+{
+ const char* strRules[] = {
+ "[reorder Hani] &b<a"
+ };
+ /*const int32_t apiRules[] = {
+ USCRIPT_HAN
+ };*/
+
+ const static OneTestCase privateUseCharacterStrings[] = {
+ { {0x4e00}, {0x0041}, UCOL_LESS },
+ { {0x4e00}, {0x0060}, UCOL_GREATER },
+ { {0xD86D, 0xDF40}, {0x0041}, UCOL_LESS },
+ { {0xD86D, 0xDF40}, {0x0060}, UCOL_GREATER },
+ { {0x4e00}, {0xD86D, 0xDF40}, UCOL_LESS },
+ { {0xfa27}, {0x0041}, UCOL_LESS },
+ { {0xD869, 0xDF00}, {0x0041}, UCOL_LESS },
+ { {0x0062}, {0x0061}, UCOL_LESS },
+ };
+
+ /* Test rules creation */
+ doTestOneTestCase(privateUseCharacterStrings, UPRV_LENGTHOF(privateUseCharacterStrings), strRules, UPRV_LENGTHOF(strRules));
+}
+
+static void TestMultipleReorder(void)
+{
+ const char* strRules[] = {
+ "[reorder Grek Zzzz DIGIT Latn Hani]"
};
- const static char *test[] = {
- "l\\u0101",
- "la",
- "l\\u0101n",
- "lan ",
- "l\\u0113",
- "le",
- "l\\u0113n",
- "len"
+ const int32_t apiRules[] = {
+ USCRIPT_GREEK, USCRIPT_UNKNOWN, UCOL_REORDER_CODE_DIGIT, USCRIPT_LATIN, USCRIPT_HAN
};
+
+ const static OneTestCase collationTestCases[] = {
+ { {0x0391}, {0x0041}, UCOL_LESS},
+ { {0x0031}, {0x0041}, UCOL_LESS},
+ { {0x0041}, {0x4e00}, UCOL_LESS},
+ };
+
+ /* Test rules creation */
+ doTestOneTestCase(collationTestCases, UPRV_LENGTHOF(collationTestCases), strRules, UPRV_LENGTHOF(strRules));
+
+ /* Test collation reordering API */
+ doTestOneReorderingAPITestCase(collationTestCases, UPRV_LENGTHOF(collationTestCases), apiRules, UPRV_LENGTHOF(apiRules));
+}
+
+/*
+ * Test that covers issue reported in ticket 8814
+ */
+static void TestReorderWithNumericCollation(void)
+{
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *myCollation;
+ UCollator *myReorderCollation;
+ int32_t reorderCodes[] = {UCOL_REORDER_CODE_SPACE, UCOL_REORDER_CODE_PUNCTUATION, UCOL_REORDER_CODE_SYMBOL, UCOL_REORDER_CODE_DIGIT, USCRIPT_GREEK,USCRIPT_LATIN, USCRIPT_HEBREW, UCOL_REORDER_CODE_OTHERS};
+ /* UChar fortyS[] = { 0x0034, 0x0030, 0x0053 };
+ UChar fortyThreeP[] = { 0x0034, 0x0033, 0x0050 }; */
+ UChar fortyS[] = { 0x0053 };
+ UChar fortyThreeP[] = { 0x0050 };
+ uint8_t fortyS_sortKey[128];
+ int32_t fortyS_sortKey_Length;
+ uint8_t fortyThreeP_sortKey[128];
+ int32_t fortyThreeP_sortKey_Length;
+ uint8_t fortyS_sortKey_reorder[128];
+ int32_t fortyS_sortKey_reorder_Length;
+ uint8_t fortyThreeP_sortKey_reorder[128];
+ int32_t fortyThreeP_sortKey_reorder_Length;
+ UCollationResult collResult;
+ UCollationResult collResultReorder;
+
+ log_verbose("Testing reordering with and without numeric collation\n");
+
+ /* build collator tertiary with numeric */
+ myCollation = ucol_open("", &status);
+ /*
+ ucol_setStrength(myCollation, UCOL_TERTIARY);
+ */
+ ucol_setAttribute(myCollation, UCOL_NUMERIC_COLLATION, UCOL_ON, &status);
+ if(U_FAILURE(status)) {
+ log_err_status(status, "ERROR: in creation of collator: %s\n", myErrorName(status));
+ return;
+ }
+
+ /* build collator tertiary with numeric and reordering */
+ myReorderCollation = ucol_open("", &status);
+ /*
+ ucol_setStrength(myReorderCollation, UCOL_TERTIARY);
+ */
+ ucol_setAttribute(myReorderCollation, UCOL_NUMERIC_COLLATION, UCOL_ON, &status);
+ ucol_setReorderCodes(myReorderCollation, reorderCodes, UPRV_LENGTHOF(reorderCodes), &status);
+ if(U_FAILURE(status)) {
+ log_err_status(status, "ERROR: in creation of collator: %s\n", myErrorName(status));
+ return;
+ }
+
+ fortyS_sortKey_Length = ucol_getSortKey(myCollation, fortyS, UPRV_LENGTHOF(fortyS), fortyS_sortKey, 128);
+ fortyThreeP_sortKey_Length = ucol_getSortKey(myCollation, fortyThreeP, UPRV_LENGTHOF(fortyThreeP), fortyThreeP_sortKey, 128);
+ fortyS_sortKey_reorder_Length = ucol_getSortKey(myReorderCollation, fortyS, UPRV_LENGTHOF(fortyS), fortyS_sortKey_reorder, 128);
+ fortyThreeP_sortKey_reorder_Length = ucol_getSortKey(myReorderCollation, fortyThreeP, UPRV_LENGTHOF(fortyThreeP), fortyThreeP_sortKey_reorder, 128);
+
+ if (fortyS_sortKey_Length < 0 || fortyThreeP_sortKey_Length < 0 || fortyS_sortKey_reorder_Length < 0 || fortyThreeP_sortKey_reorder_Length < 0) {
+ log_err_status(status, "ERROR: couldn't generate sort keys\n");
+ return;
+ }
+ collResult = ucol_strcoll(myCollation, fortyS, UPRV_LENGTHOF(fortyS), fortyThreeP, UPRV_LENGTHOF(fortyThreeP));
+ collResultReorder = ucol_strcoll(myReorderCollation, fortyS, UPRV_LENGTHOF(fortyS), fortyThreeP, UPRV_LENGTHOF(fortyThreeP));
+ /*
+ fprintf(stderr, "\tcollResult = %x\n", collResult);
+ fprintf(stderr, "\tcollResultReorder = %x\n", collResultReorder);
+ fprintf(stderr, "\nfortyS\n");
+ for (i = 0; i < fortyS_sortKey_Length; i++) {
+ fprintf(stderr, "%x --- %x\n", fortyS_sortKey[i], fortyS_sortKey_reorder[i]);
+ }
+ fprintf(stderr, "\nfortyThreeP\n");
+ for (i = 0; i < fortyThreeP_sortKey_Length; i++) {
+ fprintf(stderr, "%x --- %x\n", fortyThreeP_sortKey[i], fortyThreeP_sortKey_reorder[i]);
+ }
+ */
+ if (collResult != collResultReorder) {
+ log_err_status(status, "ERROR: collation results should have been the same.\n");
+ return;
+ }
+
+ ucol_close(myCollation);
+ ucol_close(myReorderCollation);
+}
+
+static int compare_uint8_t_arrays(const uint8_t* a, const uint8_t* b)
+{
+ for (; *a == *b; ++a, ++b) {
+ if (*a == 0) {
+ return 0;
+ }
+ }
+ return (*a < *b ? -1 : 1);
+}
- const static char *test2[] = {
- "x\\u0101",
- "x\\u0100",
- "X\\u0101",
- "X\\u0100",
- "x\\u00E1",
- "x\\u00C1",
- "X\\u00E1",
- "X\\u00C1",
- "x\\u01CE",
- "x\\u01CD",
- "X\\u01CE",
- "X\\u01CD",
- "x\\u00E0",
- "x\\u00C0",
- "X\\u00E0",
- "X\\u00C0",
- "xa",
- "xA",
- "Xa",
- "XA",
- "x\\u0101x",
- "x\\u0100x",
- "x\\u00E1x",
- "x\\u00C1x",
- "x\\u01CEx",
- "x\\u01CDx",
- "x\\u00E0x",
- "x\\u00C0x",
- "xax",
- "xAx"
- };
+static void TestImportRulesDeWithPhonebook(void)
+{
+ const char* normalRules[] = {
+ "&a<\\u00e6<\\u00c6<\\u00dc<\\u00fc",
+ "&a<<\\u00e6<<\\u00c6<<\\u00dc<<\\u00fc",
+ "&a<<\\u00e6<<<\\u00c6<<\\u00dc<<\\u00fc",
+ };
+ const OneTestCase normalTests[] = {
+ { {0x00e6}, {0x00c6}, UCOL_LESS},
+ { {0x00fc}, {0x00dc}, UCOL_GREATER},
+ };
+
+ const char* importRules[] = {
+ "&a<\\u00e6<\\u00c6<\\u00dc<\\u00fc[import de-u-co-phonebk]",
+ "&a<<\\u00e6<<\\u00c6<<\\u00dc<<\\u00fc[import de-u-co-phonebk]",
+ "&a<<\\u00e6<<<\\u00c6<<\\u00dc<<\\u00fc[import de-u-co-phonebk]",
+ };
+ const OneTestCase importTests[] = {
+ { {0x00e6}, {0x00c6}, UCOL_LESS},
+ { {0x00fc}, {0x00dc}, UCOL_LESS},
+ };
- genericRulesStarter(rules, test, sizeof(test)/sizeof(test[0]));
- genericLocaleStarter("zh", test, sizeof(test)/sizeof(test[0]));
- genericRulesStarter(rules, test2, sizeof(test2)/sizeof(test2[0]));
- genericLocaleStarter("zh", test2, sizeof(test2)/sizeof(test2[0]));
+ doTestOneTestCase(normalTests, UPRV_LENGTHOF(normalTests), normalRules, UPRV_LENGTHOF(normalRules));
+ doTestOneTestCase(importTests, UPRV_LENGTHOF(importTests), importRules, UPRV_LENGTHOF(importRules));
}
-static void TestBeforeTightening(void) {
- struct {
- const char *rules;
- UErrorCode expectedStatus;
- } tests[] = {
- { "&[before 1]a<x", U_ZERO_ERROR },
- { "&[before 1]a<<x", U_INVALID_FORMAT_ERROR },
- { "&[before 1]a<<<x", U_INVALID_FORMAT_ERROR },
- { "&[before 1]a=x", U_INVALID_FORMAT_ERROR },
- { "&[before 2]a<x",U_INVALID_FORMAT_ERROR },
- { "&[before 2]a<<x",U_ZERO_ERROR },
- { "&[before 2]a<<<x",U_INVALID_FORMAT_ERROR },
- { "&[before 2]a=x",U_INVALID_FORMAT_ERROR },
- { "&[before 3]a<x",U_INVALID_FORMAT_ERROR },
- { "&[before 3]a<<x",U_INVALID_FORMAT_ERROR },
- { "&[before 3]a<<<x",U_ZERO_ERROR },
- { "&[before 3]a=x",U_INVALID_FORMAT_ERROR },
- { "&[before I]a = x",U_INVALID_FORMAT_ERROR }
- };
+#if 0
+static void TestImportRulesFiWithEor(void)
+{
+ /* DUCET. */
+ const char* defaultRules[] = {
+ "&a<b", /* Dummy rule. */
+ };
- int32_t i = 0;
+ const OneTestCase defaultTests[] = {
+ { {0x0110}, {0x00F0}, UCOL_LESS},
+ { {0x00a3}, {0x00a5}, UCOL_LESS},
+ { {0x0061}, {0x0061, 0x00a3}, UCOL_LESS},
+ };
- UErrorCode status = U_ZERO_ERROR;
- UChar rlz[RULE_BUFFER_LEN] = { 0 };
- uint32_t rlen = 0;
+ /* European Ordering rules: ignore currency characters. */
+ const char* eorRules[] = {
+ "[import root-u-co-eor]",
+ };
- UCollator *coll = NULL;
+ const OneTestCase eorTests[] = {
+ { {0x0110}, {0x00F0}, UCOL_LESS},
+ { {0x00a3}, {0x00a5}, UCOL_EQUAL},
+ { {0x0061}, {0x0061, 0x00a3}, UCOL_EQUAL},
+ };
+ const char* fiStdRules[] = {
+ "[import fi-u-co-standard]",
+ };
- for(i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
- rlen = u_unescape(tests[i].rules, rlz, RULE_BUFFER_LEN);
- coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &status);
- if(status != tests[i].expectedStatus) {
- log_err("Opening a collator with rules %s returned error code %s, expected %s\n",
- tests[i].rules, u_errorName(status), u_errorName(tests[i].expectedStatus));
+ const OneTestCase fiStdTests[] = {
+ { {0x0110}, {0x00F0}, UCOL_GREATER},
+ { {0x00a3}, {0x00a5}, UCOL_LESS},
+ { {0x0061}, {0x0061, 0x00a3}, UCOL_LESS},
+ };
+
+ /* Both European Ordering Rules and Fi Standard Rules. */
+ const char* eorFiStdRules[] = {
+ "[import root-u-co-eor][import fi-u-co-standard]",
+ };
+
+ /* This is essentially same as the one before once fi.txt is updated with import. */
+ const char* fiEorRules[] = {
+ "[import fi-u-co-eor]",
+ };
+
+ const OneTestCase fiEorTests[] = {
+ { {0x0110}, {0x00F0}, UCOL_GREATER},
+ { {0x00a3}, {0x00a5}, UCOL_EQUAL},
+ { {0x0061}, {0x0061, 0x00a3}, UCOL_EQUAL},
+ };
+
+ doTestOneTestCase(defaultTests, UPRV_LENGTHOF(defaultTests), defaultRules, UPRV_LENGTHOF(defaultRules));
+ doTestOneTestCase(eorTests, UPRV_LENGTHOF(eorTests), eorRules, UPRV_LENGTHOF(eorRules));
+ doTestOneTestCase(fiStdTests, UPRV_LENGTHOF(fiStdTests), fiStdRules, UPRV_LENGTHOF(fiStdRules));
+ doTestOneTestCase(fiEorTests, UPRV_LENGTHOF(fiEorTests), eorFiStdRules, UPRV_LENGTHOF(eorFiStdRules));
+
+ log_knownIssue("8962", NULL);
+ /* TODO: Fix ICU ticket #8962 by uncommenting the following test after fi.txt is updated with the following rule:
+ eor{
+ Sequence{
+ "[import root-u-co-eor][import fi-u-co-standard]"
+ }
+ Version{"21.0"}
}
- ucol_close(coll);
- status = U_ZERO_ERROR;
- }
+ */
+ /* doTestOneTestCase(fiEorTests, UPRV_LENGTHOF(fiEorTests), fiEorRules, UPRV_LENGTHOF(fiEorRules)); */
}
+#endif
#if 0
-&m < a
-&[before 1] a < x <<< X << q <<< Q < z
-assert: m <<< M < x <<< X << q <<< Q < z < a < n
+/*
+ * This test case tests inclusion with the unihan rules, but this cannot be included now, unless
+ * the resource files are built with -includeUnihanColl option.
+ * TODO: Uncomment this function and make it work when unihan rules are built by default.
+ */
+static void TestImportRulesCJKWithUnihan(void)
+{
+ /* DUCET. */
+ const char* defaultRules[] = {
+ "&a<b", /* Dummy rule. */
+ };
-&m < a
-&[before 2] a << x <<< X << q <<< Q < z
-assert: m <<< M < x <<< X << q <<< Q << a < z < n
+ const OneTestCase defaultTests[] = {
+ { {0x3402}, {0x4e1e}, UCOL_GREATER},
+ };
-&m < a
-&[before 3] a <<< x <<< X << q <<< Q < z
-assert: m <<< M < x <<< X <<< a << q <<< Q < z < n
+ /* European Ordering rules: ignore currency characters. */
+ const char* unihanRules[] = {
+ "[import ko-u-co-unihan]",
+ };
+ const OneTestCase unihanTests[] = {
+ { {0x3402}, {0x4e1e}, UCOL_LESS},
+ };
-&m << a
-&[before 1] a < x <<< X << q <<< Q < z
-assert: x <<< X << q <<< Q < z < m <<< M << a < n
+ doTestOneTestCase(defaultTests, UPRV_LENGTHOF(defaultTests), defaultRules, UPRV_LENGTHOF(defaultRules));
+ doTestOneTestCase(unihanTests, UPRV_LENGTHOF(unihanTests), unihanRules, UPRV_LENGTHOF(unihanRules));
-&m << a
-&[before 2] a << x <<< X << q <<< Q < z
-assert: m <<< M << x <<< X << q <<< Q << a < z < n
+}
+#endif
-&m << a
-&[before 3] a <<< x <<< X << q <<< Q < z
-assert: m <<< M << x <<< X <<< a << q <<< Q < z < n
+static void TestImport(void)
+{
+ UCollator* vicoll;
+ UCollator* escoll;
+ UCollator* viescoll;
+ UCollator* importviescoll;
+ UParseError error;
+ UErrorCode status = U_ZERO_ERROR;
+ UChar* virules;
+ int32_t viruleslength;
+ UChar* esrules;
+ int32_t esruleslength;
+ UChar* viesrules;
+ int32_t viesruleslength;
+ char srules[500] = "[import vi][import es]";
+ UChar rules[500];
+ uint32_t length = 0;
+ int32_t itemCount;
+ int32_t i, k;
+ UChar32 start;
+ UChar32 end;
+ UChar str[500];
+ int32_t strLength;
+
+ uint8_t sk1[500];
+ uint8_t sk2[500];
+
+ UBool b;
+ USet* tailoredSet;
+ USet* importTailoredSet;
+
+
+ vicoll = ucol_open("vi", &status);
+ if(U_FAILURE(status)){
+ log_err_status(status, "ERROR: Call ucol_open(\"vi\", ...): %s\n", myErrorName(status));
+ return;
+ }
+ virules = (UChar*) ucol_getRules(vicoll, &viruleslength);
+ if(viruleslength == 0) {
+ log_data_err("missing vi tailoring rule string\n");
+ ucol_close(vicoll);
+ return;
+ }
+ escoll = ucol_open("es", &status);
+ esrules = (UChar*) ucol_getRules(escoll, &esruleslength);
+ viesrules = (UChar*)uprv_malloc((viruleslength+esruleslength+1)*sizeof(UChar*));
+ viesrules[0] = 0;
+ u_strcat(viesrules, virules);
+ u_strcat(viesrules, esrules);
+ viesruleslength = viruleslength + esruleslength;
+ viescoll = ucol_openRules(viesrules, viesruleslength, UCOL_ON, UCOL_TERTIARY, &error, &status);
+
+ /* u_strFromUTF8(rules, 500, &length, srules, strlen(srules), &status); */
+ length = u_unescape(srules, rules, 500);
+ importviescoll = ucol_openRules(rules, length, UCOL_ON, UCOL_TERTIARY, &error, &status);
+ if(U_FAILURE(status)){
+ log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
+ return;
+ }
-&m <<< a
-&[before 1] a < x <<< X << q <<< Q < z
-assert: x <<< X << q <<< Q < z < n < m <<< a <<< M
+ tailoredSet = ucol_getTailoredSet(viescoll, &status);
+ importTailoredSet = ucol_getTailoredSet(importviescoll, &status);
-&m <<< a
-&[before 2] a << x <<< X << q <<< Q < z
-assert: x <<< X << q <<< Q << m <<< a <<< M < z < n
+ if(!uset_equals(tailoredSet, importTailoredSet)){
+ log_err("Tailored sets not equal");
+ }
-&m <<< a
-&[before 3] a <<< x <<< X << q <<< Q < z
-assert: m <<< x <<< X <<< a <<< M << q <<< Q < z < n
+ uset_close(importTailoredSet);
+
+ itemCount = uset_getItemCount(tailoredSet);
+
+ for( i = 0; i < itemCount; i++){
+ strLength = uset_getItem(tailoredSet, i, &start, &end, str, 500, &status);
+ if(strLength < 2){
+ for (; start <= end; start++){
+ k = 0;
+ U16_APPEND(str, k, 500, start, b);
+ (void)b; /* Suppress set but not used warning. */
+ ucol_getSortKey(viescoll, str, 1, sk1, 500);
+ ucol_getSortKey(importviescoll, str, 1, sk2, 500);
+ if(compare_uint8_t_arrays(sk1, sk2) != 0){
+ log_err("Sort key for %s not equal\n", str);
+ break;
+ }
+ }
+ }else{
+ ucol_getSortKey(viescoll, str, strLength, sk1, 500);
+ ucol_getSortKey(importviescoll, str, strLength, sk2, 500);
+ if(compare_uint8_t_arrays(sk1, sk2) != 0){
+ log_err("ZZSort key for %s not equal\n", str);
+ break;
+ }
+ }
+ }
-&[before 1] s < x <<< X << q <<< Q < z
-assert: r <<< R < x <<< X << q <<< Q < z < s < n
+ uset_close(tailoredSet);
-&[before 2] s << x <<< X << q <<< Q < z
-assert: r <<< R < x <<< X << q <<< Q << s < z < n
+ uprv_free(viesrules);
-&[before 3] s <<< x <<< X << q <<< Q < z
-assert: r <<< R < x <<< X <<< s << q <<< Q < z < n
+ ucol_close(vicoll);
+ ucol_close(escoll);
+ ucol_close(viescoll);
+ ucol_close(importviescoll);
+}
+static void TestImportWithType(void)
+{
+ UCollator* vicoll;
+ UCollator* decoll;
+ UCollator* videcoll;
+ UCollator* importvidecoll;
+ UParseError error;
+ UErrorCode status = U_ZERO_ERROR;
+ const UChar* virules;
+ int32_t viruleslength;
+ const UChar* derules;
+ int32_t deruleslength;
+ UChar* viderules;
+ int32_t videruleslength;
+ const char srules[500] = "[import vi][import de-u-co-phonebk]";
+ UChar rules[500];
+ uint32_t length = 0;
+ int32_t itemCount;
+ int32_t i, k;
+ UChar32 start;
+ UChar32 end;
+ UChar str[500];
+ int32_t strLength;
+
+ uint8_t sk1[500];
+ uint8_t sk2[500];
+
+ USet* tailoredSet;
+ USet* importTailoredSet;
+
+ vicoll = ucol_open("vi", &status);
+ if(U_FAILURE(status)){
+ log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
+ return;
+ }
+ virules = ucol_getRules(vicoll, &viruleslength);
+ if(viruleslength == 0) {
+ log_data_err("missing vi tailoring rule string\n");
+ ucol_close(vicoll);
+ return;
+ }
+ /* decoll = ucol_open("de@collation=phonebook", &status); */
+ decoll = ucol_open("de-u-co-phonebk", &status);
+ if(U_FAILURE(status)){
+ log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
+ return;
+ }
-&[before 1] \u24DC < x <<< X << q <<< Q < z
-assert: x <<< X << q <<< Q < z < n < m <<< \u24DC <<< M
-&[before 2] \u24DC << x <<< X << q <<< Q < z
-assert: x <<< X << q <<< Q << m <<< \u24DC <<< M < z < n
+ derules = ucol_getRules(decoll, &deruleslength);
+ viderules = (UChar*)uprv_malloc((viruleslength+deruleslength+1)*sizeof(UChar*));
+ viderules[0] = 0;
+ u_strcat(viderules, virules);
+ u_strcat(viderules, derules);
+ videruleslength = viruleslength + deruleslength;
+ videcoll = ucol_openRules(viderules, videruleslength, UCOL_ON, UCOL_TERTIARY, &error, &status);
-&[before 3] \u24DC <<< x <<< X << q <<< Q < z
-assert: m <<< x <<< X <<< \u24DC <<< M << q <<< Q < z < n
-#endif
+ /* u_strFromUTF8(rules, 500, &length, srules, strlen(srules), &status); */
+ length = u_unescape(srules, rules, 500);
+ importvidecoll = ucol_openRules(rules, length, UCOL_ON, UCOL_TERTIARY, &error, &status);
+ if(U_FAILURE(status)){
+ log_err_status(status, "ERROR: in creation of rule based collator: %s\n", myErrorName(status));
+ return;
+ }
+ tailoredSet = ucol_getTailoredSet(videcoll, &status);
+ importTailoredSet = ucol_getTailoredSet(importvidecoll, &status);
-#if 0
-/* requires features not yet supported */
-static void TestMoreBefore(void) {
- struct {
- const char* rules;
- const char* order[20];
- int32_t size;
- } tests[] = {
- { "&m < a &[before 1] a < x <<< X << q <<< Q < z",
- { "m","M","x","X","q","Q","z","a","n" }, 9},
- { "&m < a &[before 2] a << x <<< X << q <<< Q < z",
- { "m","M","x","X","q","Q","a","z","n" }, 9},
- { "&m < a &[before 3] a <<< x <<< X << q <<< Q < z",
- { "m","M","x","X","a","q","Q","z","n" }, 9},
- { "&m << a &[before 1] a < x <<< X << q <<< Q < z",
- { "x","X","q","Q","z","m","M","a","n" }, 9},
- { "&m << a &[before 2] a << x <<< X << q <<< Q < z",
- { "m","M","x","X","q","Q","a","z","n" }, 9},
- { "&m << a &[before 3] a <<< x <<< X << q <<< Q < z",
- { "m","M","x","X","a","q","Q","z","n" }, 9},
- { "&m <<< a &[before 1] a < x <<< X << q <<< Q < z",
- { "x","X","q","Q","z","n","m","a","M" }, 9},
- { "&m <<< a &[before 2] a << x <<< X << q <<< Q < z",
- { "x","X","q","Q","m","a","M","z","n" }, 9},
- { "&m <<< a &[before 3] a <<< x <<< X << q <<< Q < z",
- { "m","x","X","a","M","q","Q","z","n" }, 9},
- { "&[before 1] s < x <<< X << q <<< Q < z",
- { "r","R","x","X","q","Q","z","s","n" }, 9},
- { "&[before 2] s << x <<< X << q <<< Q < z",
- { "r","R","x","X","q","Q","s","z","n" }, 9},
- { "&[before 3] s <<< x <<< X << q <<< Q < z",
- { "r","R","x","X","s","q","Q","z","n" }, 9},
- { "&[before 1] \\u24DC < x <<< X << q <<< Q < z",
- { "x","X","q","Q","z","n","m","\\u24DC","M" }, 9},
- { "&[before 2] \\u24DC << x <<< X << q <<< Q < z",
- { "x","X","q","Q","m","\\u24DC","M","z","n" }, 9},
- { "&[before 3] \\u24DC <<< x <<< X << q <<< Q < z",
- { "m","x","X","\\u24DC","M","q","Q","z","n" }, 9}
- };
+ if(!uset_equals(tailoredSet, importTailoredSet)){
+ log_err("Tailored sets not equal");
+ }
- int32_t i = 0;
+ uset_close(importTailoredSet);
+
+ itemCount = uset_getItemCount(tailoredSet);
+
+ for( i = 0; i < itemCount; i++){
+ strLength = uset_getItem(tailoredSet, i, &start, &end, str, 500, &status);
+ if(strLength < 2){
+ for (; start <= end; start++){
+ k = 0;
+ U16_APPEND_UNSAFE(str, k, start);
+ ucol_getSortKey(videcoll, str, 1, sk1, 500);
+ ucol_getSortKey(importvidecoll, str, 1, sk2, 500);
+ if(compare_uint8_t_arrays(sk1, sk2) != 0){
+ log_err("Sort key for %s not equal\n", str);
+ break;
+ }
+ }
+ }else{
+ ucol_getSortKey(videcoll, str, strLength, sk1, 500);
+ ucol_getSortKey(importvidecoll, str, strLength, sk2, 500);
+ if(compare_uint8_t_arrays(sk1, sk2) != 0){
+ log_err("Sort key for %s not equal\n", str);
+ break;
+ }
- for(i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
- genericRulesStarter(tests[i].rules, tests[i].order, tests[i].size);
+ }
}
+
+ uset_close(tailoredSet);
+
+ uprv_free(viderules);
+
+ ucol_close(videcoll);
+ ucol_close(importvidecoll);
+ ucol_close(vicoll);
+ ucol_close(decoll);
}
-#endif
-static void TestTailorNULL( void ) {
- const static char* rule = "&a <<< '\\u0000'";
+/* 'IV INTERNATIONAL SCIENTIFIC - PRACTICAL CONFERENCE "GEOPOLITICS, GEOECONOMICS AND INTERNATIONAL RELATIONS PROBLEMS" 22-23 June 2010, St. Petersburg, Russia' */
+static const UChar longUpperStr1[]= { /* 155 chars */
+ 0x49, 0x56, 0x20, 0x49, 0x4E, 0x54, 0x45, 0x52, 0x4E, 0x41, 0x54, 0x49, 0x4F, 0x4E, 0x41, 0x4C,
+ 0x20, 0x53, 0x43, 0x49, 0x45, 0x4E, 0x54, 0x49, 0x46, 0x49, 0x43, 0x20, 0x2D, 0x20, 0x50, 0x52,
+ 0x41, 0x43, 0x54, 0x49, 0x43, 0x41, 0x4C, 0x20, 0x43, 0x4F, 0x4E, 0x46, 0x45, 0x52, 0x45, 0x4E,
+ 0x43, 0x45, 0x20, 0x22, 0x47, 0x45, 0x4F, 0x50, 0x4F, 0x4C, 0x49, 0x54, 0x49, 0x43, 0x53, 0x2C,
+ 0x20, 0x47, 0x45, 0x4F, 0x45, 0x43, 0x4F, 0x4E, 0x4F, 0x4D, 0x49, 0x43, 0x53, 0x20, 0x41, 0x4E,
+ 0x44, 0x20, 0x49, 0x4E, 0x54, 0x45, 0x52, 0x4E, 0x41, 0x54, 0x49, 0x4F, 0x4E, 0x41, 0x4C, 0x20,
+ 0x52, 0x45, 0x4C, 0x41, 0x54, 0x49, 0x4F, 0x4E, 0x53, 0x20, 0x50, 0x52, 0x4F, 0x42, 0x4C, 0x45,
+ 0x4D, 0x53, 0x22, 0x20, 0x32, 0x32, 0x2D, 0x32, 0x33, 0x20, 0x4A, 0x75, 0x6E, 0x65, 0x20, 0x32,
+ 0x30, 0x31, 0x30, 0x2C, 0x20, 0x53, 0x74, 0x2E, 0x20, 0x50, 0x65, 0x74, 0x65, 0x72, 0x73, 0x62,
+ 0x75, 0x72, 0x67, 0x2C, 0x20, 0x52, 0x75, 0x73, 0x73, 0x69, 0x61
+};
+
+/* 'BACEDIFOGUHAJEKILOMUNAPE ' with diacritics on vowels, repeated 5 times */
+static const UChar longUpperStr2[]= { /* 125 chars, > 128 collation elements */
+ 0x42,0xC1,0x43,0xC9,0x44,0xCD,0x46,0xD3,0x47,0xDA,0x48,0xC0,0x4A,0xC8,0x4B,0xCC,0x4C,0xD2,0x4D,0xD9,0x4E,0xC2,0x50,0xCA,0x20,
+ 0x42,0xC1,0x43,0xC9,0x44,0xCD,0x46,0xD3,0x47,0xDA,0x48,0xC0,0x4A,0xC8,0x4B,0xCC,0x4C,0xD2,0x4D,0xD9,0x4E,0xC2,0x50,0xCA,0x20,
+ 0x42,0xC1,0x43,0xC9,0x44,0xCD,0x46,0xD3,0x47,0xDA,0x48,0xC0,0x4A,0xC8,0x4B,0xCC,0x4C,0xD2,0x4D,0xD9,0x4E,0xC2,0x50,0xCA,0x20,
+ 0x42,0xC1,0x43,0xC9,0x44,0xCD,0x46,0xD3,0x47,0xDA,0x48,0xC0,0x4A,0xC8,0x4B,0xCC,0x4C,0xD2,0x4D,0xD9,0x4E,0xC2,0x50,0xCA,0x20,
+ 0x42,0xC1,0x43,0xC9,0x44,0xCD,0x46,0xD3,0x47,0xDA,0x48,0xC0,0x4A,0xC8,0x4B,0xCC,0x4C,0xD2,0x4D,0xD9,0x4E,0xC2,0x50,0xCA,0x20
+};
+
+/* 'ABCDEFGHIJKLMNOPQRSTUVWXYZ ' repeated 12 times */
+static const UChar longUpperStr3[]= { /* 324 chars */
+ 0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x20,
+ 0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x20,
+ 0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x20,
+ 0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x20,
+ 0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x20,
+ 0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x20,
+ 0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x20,
+ 0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x20,
+ 0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x20,
+ 0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x20,
+ 0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x20,
+ 0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x20
+};
+
+typedef struct {
+ const UChar * longUpperStrPtr;
+ int32_t longUpperStrLen;
+} LongUpperStrItem;
+
+/* String pointers must be in reverse collation order of the corresponding strings */
+static const LongUpperStrItem longUpperStrItems[] = {
+ { longUpperStr1, UPRV_LENGTHOF(longUpperStr1) },
+ { longUpperStr2, UPRV_LENGTHOF(longUpperStr2) },
+ { longUpperStr3, UPRV_LENGTHOF(longUpperStr3) },
+ { NULL, 0 }
+};
+
+enum { kCollKeyLenMax = 850 }; /* may change with collation changes */
+
+/* Text fix for #8445; without fix, could have crash due to stack or heap corruption */
+static void TestCaseLevelBufferOverflow(void)
+{
UErrorCode status = U_ZERO_ERROR;
- UChar rlz[RULE_BUFFER_LEN] = { 0 };
- uint32_t rlen = 0;
- UChar a = 1, null = 0;
- UCollationResult res = UCOL_EQUAL;
+ UCollator * ucol = ucol_open("root", &status);
+ if ( U_SUCCESS(status) ) {
+ ucol_setAttribute(ucol, UCOL_CASE_LEVEL, UCOL_ON, &status);
+ if ( U_SUCCESS(status) ) {
+ const LongUpperStrItem * itemPtr;
+ uint8_t sortKeyA[kCollKeyLenMax], sortKeyB[kCollKeyLenMax];
+ for ( itemPtr = longUpperStrItems; itemPtr->longUpperStrPtr != NULL; itemPtr++ ) {
+ int32_t sortKeyLen;
+ if (itemPtr > longUpperStrItems) {
+ uprv_strcpy((char *)sortKeyB, (char *)sortKeyA);
+ }
+ sortKeyLen = ucol_getSortKey(ucol, itemPtr->longUpperStrPtr, itemPtr->longUpperStrLen, sortKeyA, kCollKeyLenMax);
+ if (sortKeyLen <= 0 || sortKeyLen > kCollKeyLenMax) {
+ log_err("ERROR sort key length from ucol_getSortKey is %d\n", sortKeyLen);
+ break;
+ }
+ if ( itemPtr > longUpperStrItems ) {
+ int compareResult = uprv_strcmp((char *)sortKeyA, (char *)sortKeyB);
+ if (compareResult >= 0) {
+ log_err("ERROR in sort key comparison result, expected -1, got %d\n", compareResult);
+ }
+ }
+ }
+ } else {
+ log_err_status(status, "ERROR in ucol_setAttribute UCOL_CASE_LEVEL on: %s\n", myErrorName(status));
+ }
+ ucol_close(ucol);
+ } else {
+ log_err_status(status, "ERROR in ucol_open for root: %s\n", myErrorName(status));
+ }
+}
- UCollator *coll = NULL;
+/* Test for #10595 */
+static const UChar testJapaneseName[] = {0x4F50, 0x3005, 0x6728, 0x002C, 0x6B66, 0}; /* Sa sa Ki, Takeshi */
+#define KEY_PART_SIZE 16
+static void TestNextSortKeyPartJaIdentical(void)
+{
+ UErrorCode status = U_ZERO_ERROR;
+ UCollator *coll;
+ uint8_t keyPart[KEY_PART_SIZE];
+ UCharIterator iter;
+ uint32_t state[2] = {0, 0};
+ int32_t keyPartLen;
+
+ coll = ucol_open("ja", &status);
+ ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_IDENTICAL, &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: in creation of Japanese collator with identical strength: %s\n", myErrorName(status));
+ return;
+ }
- rlen = u_unescape(rule, rlz, RULE_BUFFER_LEN);
- coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &status);
- res = ucol_strcoll(coll, &a, 1, &null, 1);
- if(res != UCOL_LESS) {
- log_err("NULL was not tailored properly!\n");
+ uiter_setString(&iter, testJapaneseName, 5);
+ keyPartLen = KEY_PART_SIZE;
+ while (keyPartLen == KEY_PART_SIZE) {
+ keyPartLen = ucol_nextSortKeyPart(coll, &iter, state, keyPart, KEY_PART_SIZE, &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "ERROR: in iterating next sort key part: %s\n", myErrorName(status));
+ break;
+ }
}
+
ucol_close(coll);
}
TEST(TestExtremeCompression);
TEST(TestSurrogates);
TEST(TestVariableTopSetting);
+ TEST(TestMaxVariable);
TEST(TestBocsuCoverage);
TEST(TestCyrillicTailoring);
TEST(TestCase);
TEST(BlackBirdTest);
TEST(FunkyATest);
TEST(BillFairmanTest);
- TEST(RamsRulesTest);
- TEST(IsTailoredTest);
- TEST(TestCollations);
TEST(TestChMove);
TEST(TestImplicitTailoring);
TEST(TestFCDProblem);
TEST(TestEmptyRule);
/*TEST(TestJ784);*/ /* 'zh' locale has changed - now it is getting tested by TestBeforePinyin */
TEST(TestJ815);
- /*TEST(TestJ831);*/ /* we changed lv locale */
+ TEST(TestUpperCaseFirst);
TEST(TestBefore);
- TEST(TestRedundantRules);
- TEST(TestExpansionSyntax);
TEST(TestHangulTailoring);
TEST(TestUCARules);
TEST(TestIncrementalNormalize);
TEST(TestNumericCollation);
TEST(TestTibetanConformance);
TEST(TestPinyinProblem);
- TEST(TestImplicitGeneration);
TEST(TestSeparateTrees);
TEST(TestBeforePinyin);
TEST(TestBeforeTightening);
/*TEST(TestMoreBefore);*/
TEST(TestTailorNULL);
+ TEST(TestUpperFirstQuaternary);
+ TEST(TestJ4960);
+ TEST(TestJ5223);
+ TEST(TestJ5232);
+ TEST(TestJ5367);
+ TEST(TestHiragana);
+ TEST(TestSortKeyConsistency);
+ TEST(TestVI5913); /* VI, RO tailored rules */
+ TEST(TestCroatianSortKey);
+ TEST(TestTailor6179);
+ TEST(TestUCAPrecontext);
+ TEST(TestOutOfBuffer5468);
+ TEST(TestSameStrengthList);
+
+ TEST(TestSameStrengthListQuoted);
+ TEST(TestSameStrengthListSupplemental);
+ TEST(TestSameStrengthListQwerty);
+ TEST(TestSameStrengthListQuotedQwerty);
+ TEST(TestSameStrengthListRanges);
+ TEST(TestSameStrengthListSupplementalRanges);
+ TEST(TestSpecialCharacters);
+ TEST(TestPrivateUseCharacters);
+ TEST(TestPrivateUseCharactersInList);
+ TEST(TestPrivateUseCharactersInRange);
+ TEST(TestInvalidListsAndRanges);
+ TEST(TestImportRulesDeWithPhonebook);
+ /* TEST(TestImportRulesFiWithEor); EOR rules removed from CLDR 21 */
+ /* TEST(TestImportRulesCJKWithUnihan); */
+ TEST(TestImport);
+ TEST(TestImportWithType);
+
+ TEST(TestBeforeRuleWithScriptReordering);
+ TEST(TestNonLeadBytesDuringCollationReordering);
+ TEST(TestReorderingAPI);
+ TEST(TestReorderingAPIWithRuleCreatedCollator);
+ TEST(TestEquivalentReorderingScripts);
+ TEST(TestGreekFirstReorder);
+ TEST(TestGreekLastReorder);
+ TEST(TestNonScriptReorder);
+ TEST(TestHaniReorder);
+ TEST(TestHaniReorderWithOtherRules);
+ TEST(TestMultipleReorder);
+ TEST(TestReorderingAcrossCloning);
+ TEST(TestReorderWithNumericCollation);
+
+ TEST(TestCaseLevelBufferOverflow);
+ TEST(TestNextSortKeyPartJaIdentical);
}
#endif /* #if !UCONFIG_NO_COLLATION */
-
projects / apple / icu.git / blobdiff