/********************************************************************
* COPYRIGHT:
- * Copyright (c) 2001-2003, International Business Machines Corporation and
+ * Copyright (c) 2001-2004, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
/*******************************************************************************
#include "ucol_tok.h"
#include "cmemory.h"
#include "cstring.h"
+#include "uassert.h"
#include "unicode/parseerr.h"
#include "unicode/ucnv.h"
#include "uparse.h"
-#define MAX_TOKEN_LEN 16
-#define RULE_BUFFER_LEN 8192
+#define LEN(a) (sizeof(a)/sizeof(a[0]))
-void genericLocaleStarter(const char *locale, const char *s[], uint32_t size); /* keep gcc happy */
+#define MAX_TOKEN_LEN 16
typedef int tst_strcoll(void *collator, const int object,
const UChar *source, const int sLen,
const UChar *target, const int tLen);
-/**
- * Return an integer array containing all of the collation orders
- * returned by calls to next on the specified iterator
- */
-static int32_t* getOrders(UCollationElements *iter, int32_t *orderLength)
-{
- UErrorCode status;
- int32_t order;
- int32_t maxSize = 100;
- int32_t size = 0;
- int32_t *temp;
- int32_t *orders =(int32_t*)malloc(sizeof(int32_t) * maxSize);
- status= U_ZERO_ERROR;
-
-
- while ((order=ucol_next(iter, &status)) != UCOL_NULLORDER)
- {
- if (size == maxSize)
- {
- maxSize *= 2;
- temp = (int32_t*)malloc(sizeof(int32_t) * maxSize);
-
- memcpy(temp, orders, size * sizeof(int32_t));
- free(orders);
- orders = temp;
-
- }
-
- orders[size++] = order;
- }
-
- if (maxSize > size && size > 0)
- {
- temp = (int32_t*)malloc(sizeof(int32_t) * size);
-
- memcpy(temp, orders, size * sizeof(int32_t));
- free(orders);
- orders = temp;
-
-
- }
-
- *orderLength = size;
- return orders;
-}
-
-static void backAndForth(UCollationElements *iter)
-{
- /* Run through the iterator forwards and stick it into an array */
- int32_t index, o;
- UErrorCode status = U_ZERO_ERROR;
- int32_t orderLength = 0;
- int32_t *orders;
- orders= getOrders(iter, &orderLength);
-
-
- /* Now go through it backwards and make sure we get the same values */
- index = orderLength;
- ucol_reset(iter);
-
- /* synwee : changed */
- while ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER)
- {
- if (o != orders[-- index])
- {
- if (o == 0)
- index ++;
- else
- {
- while (index > 0 && orders[-- index] == 0)
- {
- }
- if (o != orders[index])
- {
- log_err("Mismatch at index : %d\n", index);
- break;
- }
- }
- }
- }
-
- while (index != 0 && orders[index - 1] == 0) {
- index --;
- }
-
- if (index != 0)
- {
- log_err("Didn't get back to beginning - index is %d\n", index);
-
- ucol_reset(iter);
- log_err("\nnext: ");
- while ((o = ucol_next(iter, &status)) != UCOL_NULLORDER)
- {
- log_err("Error at %d\n", o);
- }
- log_err("\nprev: ");
- while ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER)
- {
- log_err("Error at %d\n", o);
- }
- log_verbose("\n");
- }
-
- free(orders);
-}
const static char cnt1[][10] = {
lr = ures_open(NULL,lp,&lec);
if (lr) {
- cr = ures_getByKey(lr,"CollationElements",0,&lec);
+ cr = ures_getByKey(lr,"collations",0,&lec);
if (cr) {
lp = ures_getLocale(cr,&lec);
if (lp) {
UBool startOfRules = TRUE;
UBool lastReset = FALSE;
UBool before = FALSE;
+ uint32_t beforeStrength = 0;
UColTokenParser src;
UColOptionSet opts;
startOfRules = FALSE;
varT = (UBool)((specs & UCOL_TOK_VARIABLE_TOP) != 0);
top_ = (UBool)((specs & UCOL_TOK_TOP) != 0);
- if(top_) { /* if reset is on top, we should just continue */
- continue;
- }
- u_strncpy(second,rulesCopy+chOffset, chLen);
- second[chLen] = 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;
- }
+ if(exLen > 0 && firstEx == 0) {
+ u_strncat(first, rulesCopy+exOffset, exLen);
+ first[firstLen+exLen] = 0;
+ }
- if(lastReset == TRUE && prefixLen != 0) {
- u_strncpy(first+prefixLen, first, firstLen);
- u_strncpy(first, rulesCopy+prefixOffset, prefixLen);
- first[firstLen+prefixLen] = 0;
- firstLen = firstLen+prefixLen;
- }
+ if(lastReset == TRUE && prefixLen != 0) {
+ u_strncpy(first+prefixLen, first, firstLen);
+ u_strncpy(first, rulesCopy+prefixOffset, prefixLen);
+ first[firstLen+prefixLen] = 0;
+ firstLen = firstLen+prefixLen;
+ }
- if(before == TRUE) { /* swap first and second */
- u_strcpy(tempB, first);
- u_strcpy(first, second);
- u_strcpy(second, tempB);
+ if(before == TRUE) { /* swap first and second */
+ u_strcpy(tempB, first);
+ u_strcpy(first, second);
+ u_strcpy(second, tempB);
- tempLen = firstLen;
- firstLen = chLen;
- chLen = tempLen;
+ tempLen = firstLen;
+ firstLen = chLen;
+ chLen = tempLen;
- tempLen = firstEx;
- firstEx = exLen;
- exLen = tempLen;
+ tempLen = firstEx;
+ firstEx = exLen;
+ exLen = tempLen;
+ if(beforeStrength < strength) {
+ strength = beforeStrength;
+ }
+ }
}
-
lastReset = FALSE;
switch(strength){
case UCOL_TOK_RESET:
lastReset = TRUE;
before = (UBool)((specs & UCOL_TOK_BEFORE) != 0);
+ if(before) {
+ beforeStrength = (specs & UCOL_TOK_BEFORE)-1;
+ }
break;
default:
break;
}
if(before == TRUE && strength != UCOL_TOK_RESET) { /* first and second were swapped */
- before = FALSE;
+ before = FALSE;
} else {
firstLen = chLen;
firstEx = exLen;
uint32_t i = 0;
- char sEsc[256], s[256], tEsc[256], t[256], b[256], output[256], relation[256];
+ 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(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);
}
}
}
-/*
- * Takes two CEs (lead and continuation) and
+/*
+ * Takes two CEs (lead and continuation) and
* compares them as CEs should be compared:
* primary vs. primary, secondary vs. secondary
* tertiary vs. tertiary
if(s1 == t1 && s2 == t2) {
return 0;
}
- s = (s1 & 0xFFFF0000)|((s2 & 0xFFFF0000)>>16);
- t = (t1 & 0xFFFF0000)|((t2 & 0xFFFF0000)>>16);
+ s = (s1 & 0xFFFF0000)|((s2 & 0xFFFF0000)>>16);
+ t = (t1 & 0xFFFF0000)|((t2 & 0xFFFF0000)>>16);
if(s < t) {
return -1;
} else if(s > t) {
}
}
+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;
uint16_t specs = 0;
UBool varT = FALSE; UBool top_ = TRUE;
UBool startOfRules = TRUE;
+ UBool before = FALSE;
UColTokenParser src;
UColOptionSet opts;
UParseError parseError;
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],
+ 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);
- ucol_initInverseUCA(status);
+ 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;
+ }
+
if(U_SUCCESS(*status) && ruleLen > 0) {
rulesCopy = (UChar *)malloc((ruleLen+UCOL_TOK_EXTRA_RULE_SPACE_SIZE)*sizeof(UChar));
/* we need to repack CEs here */
if(strength == UCOL_TOK_RESET) {
+ before = (UBool)((specs & UCOL_TOK_BEFORE) != 0);
if(top_ == TRUE) {
-
- nextCE = baseCE = currCE = UCOL_RESET_TOP_VALUE;
- nextContCE = baseContCE = currContCE = UCOL_RESET_TOP_CONT;
+ int32_t index = src.parsedToken.indirectIndex;
+
+ nextCE = baseCE = currCE = ucolIndirectBoundaries[index].startCE;
+ nextContCE = baseContCE = currContCE = ucolIndirectBoundaries[index].startContCE;
} else {
nextCE = baseCE = currCE;
nextContCE = baseContCE = currContCE;
nextCE = UCOL_NEXT_TOP_VALUE;
nextContCE = UCOL_NEXT_TOP_CONT;
} else {
- result = ucol_inv_getNextCE(baseCE & 0xFFFFFF3F, baseContCE, &nextCE, &nextContCE, maxStrength);
+ result = ucol_inv_getNextCE(&src, baseCE & 0xFFFFFF3F, baseContCE, &nextCE, &nextContCE, maxStrength);
}
if(result < 0) {
if(ucol_isTailored(coll, *(rulesCopy+oldOffset), status)) {
/*if(currCE > nextCE || (currCE == nextCE && currContCE >= nextContCE)) {*/
log_err("current CE is not less than base CE\n");
}
- if(compareCEs(currCE, currContCE, lastCE, lastContCE) < 0) {
- /*if(currCE < lastCE || (currCE == lastCE && currContCE <= lastContCE)) {*/
- log_err("sequence of generated CEs is broken\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");
+ }
}
}
}
"&[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"*/
};
-static UBool hasCollationElements(const char *locName) {
-
- UErrorCode status = U_ZERO_ERROR;
- UResourceBundle *ColEl = NULL;
-
- UResourceBundle *loc = ures_open(NULL, locName, &status);;
-
- if(U_SUCCESS(status)) {
- status = U_ZERO_ERROR;
- ColEl = ures_getByKey(loc, "CollationElements", ColEl, &status);
- if(status == U_ZERO_ERROR) { /* do the test - there are real elements */
- ures_close(ColEl);
- ures_close(loc);
- return TRUE;
- }
- ures_close(ColEl);
- ures_close(loc);
- }
- return FALSE;
-}
-
static void TestCollations(void) {
int32_t noOfLoc = uloc_countAvailable();
cName[nameSize] = 0;
log_verbose("\nTesting locale %s (%s)\n", locName, cName);
coll = ucol_open(locName, &status);
- testAgainstUCA(coll, UCA, "UCA", FALSE, &status);
- ucol_close(coll);
+ 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;
+ }
}
}
ucol_setAttribute(UCA, UCOL_STRENGTH, oldStrength, &status);
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)) {
}
}
-static void genericOrderingTestWithResult(UCollator *coll, const char *s[], uint32_t size, UCollationResult result) {
- UChar t1[2048] = {0};
- UChar t2[2048] = {0};
- UCollationElements *iter;
- UErrorCode status = U_ZERO_ERROR;
-
- uint32_t i = 0, j = 0;
- log_verbose("testing sequence:\n");
- for(i = 0; i < size; i++) {
- log_verbose("%s\n", s[i]);
- }
-
- iter = ucol_openElements(coll, t1, u_strlen(t1), &status);
- if (U_FAILURE(status)) {
- log_err("Creation of iterator failed\n");
- }
- for(i = 0; i < size-1; i++) {
- for(j = i+1; j < size; j++) {
- u_unescape(s[i], t1, 2048);
- u_unescape(s[j], t2, 2048);
- doTest(coll, t1, t2, result);
- /* synwee : added collation element iterator test */
- ucol_setText(iter, t1, u_strlen(t1), &status);
- backAndForth(iter);
- ucol_setText(iter, t2, u_strlen(t2), &status);
- backAndForth(iter);
- }
- }
- ucol_closeElements(iter);
-}
-
-static void genericOrderingTest(UCollator *coll, const char *s[], uint32_t size) {
- genericOrderingTestWithResult(coll, s, size, UCOL_LESS);
-}
-
-void genericLocaleStarter(const char *locale, const char *s[], uint32_t size) {
- UErrorCode status = U_ZERO_ERROR;
- UCollator *coll = ucol_open(locale, &status);
-
- log_verbose("Locale starter for %s\n", locale);
-
- if(U_SUCCESS(status)) {
- genericOrderingTest(coll, s, size);
- } else if(status == U_FILE_ACCESS_ERROR) {
- log_data_err("Is your data around?\n");
- return;
- } else {
- log_err("Unable to open collator for locale %s\n", locale);
- }
- ucol_close(coll);
-}
-
-#if 0
-/* currently not used with options */
-static void genericRulesStarterWithOptions(const char *rules, const char *s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, uint32_t attsize) {
- UErrorCode status = U_ZERO_ERROR;
- UChar rlz[RULE_BUFFER_LEN] = { 0 };
- uint32_t rlen = u_unescape(rules, rlz, RULE_BUFFER_LEN);
- uint32_t i;
-
- UCollator *coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &status);
-
- log_verbose("Rules starter for %s\n", rules);
-
- if(U_SUCCESS(status)) {
- log_verbose("Setting attributes\n");
- for(i = 0; i < attsize; i++) {
- ucol_setAttribute(coll, attrs[i], values[i], &status);
- }
-
- genericOrderingTest(coll, s, size);
- } else {
- log_err("Unable to open collator with rules %s\n", rules);
- }
- ucol_close(coll);
-}
-#endif
-
-static void genericLocaleStarterWithOptions(const char *locale, const char *s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, uint32_t attsize) {
- UErrorCode status = U_ZERO_ERROR;
- uint32_t i;
-
- UCollator *coll = ucol_open(locale, &status);
-
- log_verbose("Locale starter for %s\n", locale);
-
- if(U_SUCCESS(status)) {
-
- log_verbose("Setting attributes\n");
- for(i = 0; i < attsize; i++) {
- ucol_setAttribute(coll, attrs[i], values[i], &status);
- }
-
- genericOrderingTest(coll, s, size);
- } else {
- log_err("Unable to open collator for locale %s\n", locale);
- }
- ucol_close(coll);
-}
-
-static void genericRulesTestWithResult(const char *rules, const char *s[], uint32_t size, UCollationResult result) {
- UErrorCode status = U_ZERO_ERROR;
- UChar rlz[RULE_BUFFER_LEN] = { 0 };
- uint32_t rlen = u_unescape(rules, rlz, RULE_BUFFER_LEN);
-
- UCollator *coll = NULL;
- coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &status);
- log_verbose("Rules starter for %s\n", rules);
-
- if(U_SUCCESS(status)) {
- genericOrderingTestWithResult(coll, s, size, result);
- ucol_close(coll);
- } else if(status == U_FILE_ACCESS_ERROR) {
- log_data_err("Is your data around?\n");
- } else {
- log_err("Unable to open collator with rules %s\n", rules);
- }
-}
-
-static void genericRulesStarter(const char *rules, const char *s[], uint32_t size) {
- genericRulesTestWithResult(rules, s, size, UCOL_LESS);
-}
const static char chTest[][20] = {
"c",
ucol_close(coll);
}
+
+
+
const static char impTest[][20] = {
"\\u4e00",
"a",
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;
+
+ for(i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
+ genericRulesStarter(tests[i].rules, tests[i].data, tests[i].len);
+ }
+
+/*
UChar t1[256] = {0};
UChar t2[256] = {0};
log_err("Can't open collator");
}
ucol_close(coll);
+ */
}
static void TestFCDProblem(void) {
UChar32 u = 0;
UChar comp[NORM_BUFFER_TEST_LEN];
uint32_t len = 0;
+ UCollationElements *iter;
noOfLoc = uloc_countAvailable();
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);
- if(nfcSize != nfdSize || (uprv_memcmp(t[noCases]->NFC, t[noCases]->NFD, nfcSize * sizeof(UChar)) != 0)
+ 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)) {
noCases++;
t[noCases] = (tester *)malloc(sizeof(tester));
uprv_memset(t[noCases], 0, sizeof(tester));
- }
+ }
}
for(u=0; u<(UChar32)noCases; u++) {
coll = ucol_open(locName, &status);
ucol_setStrength(coll, UCOL_IDENTICAL);
+ iter = ucol_openElements(coll, t[u]->NFD, u_strlen(t[u]->NFD), &status);
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);
}
}
data, sizeof(data)/sizeof(data[0]));
}
+#if 0
+/* superceded by TestBeforePinyin */
static void TestJ784(void) {
const static char *data[] = {
"A", "\\u0101", "\\u00e1", "\\u01ce", "\\u00e0",
};
genericLocaleStarter("zh", data, sizeof(data)/sizeof(data[0]));
}
+#endif
-
+#if 0
+/* superceded by the changes to the lv locale */
static void TestJ831(void) {
const static char *data[] = {
"I",
};
genericLocaleStarter("lv", data, sizeof(data)/sizeof(data[0]));
}
+#endif
static void TestJ815(void) {
const static char *data[] = {
static void TestRedundantRules(void) {
int32_t i;
- const static char *rules[] = {
- "& a <<< b <<< c << d <<< e& [before 1] e <<< x",
- "& a < b <<< c << d <<< e& [before 1] e <<< x",
- "& a < b < c < d& [before 1] c < m",
- "& a < b <<< c << d <<< e& [before 3] e <<< x",
- "& a < b <<< c << d <<< e& [before 2] e <<< x",
- "& a < b <<< c << d <<< e <<< f < g& [before 1] g < x",
- "& a <<< b << c < d& a < m",
- "&a<b<<b\\u0301 &z<b",
- "&z<m<<<q<<<m",
- "&z<<<m<q<<<m",
- "& a < b < c < d& r < c",
- "& a < b < c < d& r < c",
- "& a < b < c < d& c < m",
- "& a < b < c < d& a < m"
- };
-
- const static char *expectedRules[] = {
- /*"&\\u3029<<<x",*/
- "&\\u2089<<<x",
- "& a <<< x < b <<< c << d <<< e",
- "& a < b < m < c < d",
- "& a < b <<< c << d <<< x <<< e",
- "& a < b <<< c <<< x << d <<< e",
- "& a < b <<< c << d <<< e <<< f < x < g",
- "& a <<< b << c < m < d",
- "&a<b\\u0301 &z<b",
- "&z<q<<<m",
- "&z<q<<<m",
- "& a < b < d& r < c",
- "& a < b < d& r < c",
- "& a < b < c < m < d",
- "& a < m < b < c < d"
- };
-
- const static char *testdata[][8] = {
- /*{"\\u3029", "x"},*/
- {"\\u2089", "x"},
- {"a", "x", "b", "c", "d", "e"},
- {"a", "b", "m", "c", "d"},
- {"a", "b", "c", "d", "x", "e"},
- {"a", "b", "c", "x", "d", "e"},
- {"a", "b", "c", "d", "e", "f", "x", "g"},
- {"a", "b", "c", "m", "d"},
- {"a", "b\\u0301", "z", "b"},
- {"z", "q", "m"},
- {"z", "q", "m"},
- {"a", "b", "d"},
- {"r", "c"},
- {"a", "b", "c", "m", "d"},
- {"a", "m", "b", "c", "d"}
- };
-
- const static uint32_t testdatalen[] = {
- 2,
- 6,
- 5,
- 6,
- 6,
- 8,
- 5,
- 4,
- 3,
- 3,
- 3,
- 2,
- 5,
- 5
+ struct {
+ const char *rules;
+ const char *expectedRules;
+ const char *testdata[8];
+ uint32_t testdatalen;
+ } 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
+ }
};
-
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);
+ 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);
credundant = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT, NULL,&status);
if(status == U_FILE_ACCESS_ERROR) {
return;
}
- rlen = u_unescape(expectedRules[i], rlz, 2048);
+ rlen = u_unescape(tests[i].expectedRules, rlz, 2048);
cresulting = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT, NULL,&status);
testAgainstUCA(cresulting, credundant, "expected", TRUE, &status);
log_verbose("testing using data\n");
- genericRulesStarter(rules[i], testdata[i], testdatalen[i]);
+ genericRulesStarter(tests[i].rules, tests[i].testdata, tests[i].testdatalen);
}
}
};
int32_t i,j,k;
UErrorCode status = U_ZERO_ERROR;
+ UCollationElements *iter;
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));
return;
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);
}
}
}
/* Test 3: Non-normal sequence is terminated by a surrogate pair.*/
{
- /* New UCA 3.1.1.
- * test below used a code point from Desseret, which sorts differently
+ /* 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};*/
};
/* Russian overrides contractions, so this test is not valid anymore */
- /*genericLocaleStarter("ru", test, 3);*/
+ /*genericLocaleStarter("ru", test, 3);*/
genericLocaleStarter("root", test, 3);
genericRulesStarter("&\\u0410 = \\u0410", test, 3);
static const char *testNoCont2[] = {
"\\u0410\\u0302a",
"\\u0410\\u0306b",
- "\\u0410c"
+ "\\u0410c"
};
static const char *testNoCont[] = {
- "a\\u0410",
+ "a\\u0410",
"A\\u0410\\u0306",
"\\uFF21\\u0410\\u0302"
};
-
+
genericRulesStarter("[suppressContractions [\\u0400-\\u047f]]", testNoCont, 3);
genericRulesStarter("[suppressContractions [\\u0400-\\u047f]]", testNoCont2, 3);
}
}
}
-/**
- * Test for CollationElementIterator previous and next for the whole set of
- * unicode characters with normalization on.
- */
-static void TestNumericCollation(void)
-{
- UCollationElements *iter;
- UErrorCode status = U_ZERO_ERROR;
-
- int i = 0, j = 0, size = 0;
- /*UCollationResult collResult;*/
- UChar t1[100], t2[100];
-
- const static char *basicTestStrings[]={
- "hello1",
- "hello2",
- "hello123456"
- };
-
- const static char *preZeroTestStrings[]={
- "avery1",
- "avery01",
- "avery001",
- "avery0001"
- };
-
- const static char *thirtyTwoBitNumericStrings[]={
- "avery42949672960",
- "avery42949672961",
- "avery42949672962",
- "avery429496729610"
- };
-
- const static char *arabicNumericStrings[]={
- "avery""\\u0660", /*avery followed by the arabic digit 0*/
- "avery""\\u0661", /*avery followed by the arabic digit 1*/
- "avery""\\u0662", /*avery followed by the arabic digit 1*/
- "avery""\\u0661\\u0662" /*avery followed by the arabic digits 1 and 2*/
- };
-
-
- /* Open our collator. */
- UCollator* coll = ucol_open(NULL, &status);
- if (U_FAILURE(status)){
- log_err("ERROR: in using ucol_open()\n %s\n",
- myErrorName(status));
- return;
- }
-
- /* 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 basic numeric collation behavior. We expect that every element in our
- strings array is less than it's predecessor. This shows that numeric collation
- works (on a superficial level).
- */
- size = sizeof(basicTestStrings)/sizeof(basicTestStrings[0]);
- for(i = 0; i < size-1; i++) {
- for(j = i+1; j < size; j++) {
- u_uastrcpy(t1, basicTestStrings[i]);
- u_uastrcpy(t2, basicTestStrings[j]);
- doTest(coll, t1, t2, UCOL_LESS);
- }
- }
- /*
- Testing that prepended zeroes still yield the correct collation behavior.
- We expect that every element in our strings array will be equal.
- */
- size = sizeof(preZeroTestStrings)/sizeof(preZeroTestStrings[0]);
- for(i = 0; i < size-1; i++) {
- for(j = i+1; j < size; j++) {
- u_uastrcpy(t1, preZeroTestStrings[i]);
- u_uastrcpy(t2, preZeroTestStrings[j]);
- doTest(coll, t1, t2, UCOL_EQUAL);
- }
- }
-
- /*
- Testing that numeric collation can handle numbers greater than 32-bits.
- We expect that every element in our strings array is less than it's successor.
- */
- size = sizeof(thirtyTwoBitNumericStrings)/sizeof(thirtyTwoBitNumericStrings[0]);
- for(i = 0; i < size-1; i++) {
- for(j = i+1; j < size; j++) {
- u_uastrcpy(t1, thirtyTwoBitNumericStrings[i]);
- u_uastrcpy(t2, thirtyTwoBitNumericStrings[j]);
- doTest(coll, t1, t2, UCOL_LESS);
- }
- }
-
- /*
- Testing that numeric collation for arabic numbers. This case is interesting because
- it ensures that non-Roman characters that have the numeric property still get processed
- correctly. We expect every element to be less than it's successor.
- */
-
- size = sizeof(arabicNumericStrings)/sizeof(arabicNumericStrings[0]);
- for(i = 0; i < size-1; i++) {
- for(j = i+1; j < size; j++) {
- u_unescape(arabicNumericStrings[i], t1,100);
- u_unescape(arabicNumericStrings[j], t2,100);
- doTest(coll, t1, t2, UCOL_LESS);
- }
- }
- /*
- Testing collation element iterator. Running backAndForth on
- a string with numbers in it should be sufficient.
- */
- u_uastrcpy(t1, basicTestStrings[2]);
- iter=ucol_openElements(coll, t1, u_strlen(t1), &status);
- backAndForth(iter);
- ucol_closeElements(iter);
-
- ucol_close(coll);
-}
-
#if 0
/* this test tests the current limitations of the engine */
/* it always fail, so it is disabled by default */
/* this test will fail when normalization is turned on */
/* therefore we always turn off exhaustive mode for it */
- if(1) { /* QUICK > 0*/
+ 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));
src.current = src.source = rulesCopy;
src.end = rulesCopy+rulesLen;
src.extraCurrent = src.end;
- src.extraEnd = src.end+UCOL_TOK_EXTRA_RULE_SPACE_SIZE;
+ src.extraEnd = src.end+UCOL_TOK_EXTRA_RULE_SPACE_SIZE;
while ((current = ucol_tok_parseNextToken(&src, startOfRules, &parseError,&status)) != NULL) {
strength = src.parsedToken.strength;
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",
+ 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",
+ log_verbose("There is a goofy contraction in UCA rules that does not appear in the fractional UCA. Codepoints: %s\n",
buffer);
}
}
const char *rules;
const char *data[50];
const uint32_t len;
- } tests[] = {
- { "&z <<< z|a",
+ } tests[] = {
+ { "&z <<< z|a",
{"zz", "za"}, 2 },
- { "&z <<< z| a",
+ { "&z <<< z| a",
{"zz", "za"}, 2 },
{ "[strength I]"
"&a=\\ud900\\udc25"
- "&z<<<\\ud900\\udc25|a",
+ "&z<<<\\ud900\\udc25|a",
{"aa", "az", "\\ud900\\udc25z", "\\ud900\\udc25a", "zz"}, 4 },
};
"\\u30c6\\u30fc\\u30bf",
"\\u30c6\\u30a7\\u30bf",
"\\u3066\\u3048\\u305f",
- "\\u3067\\u30fc\\u305f",
+ "\\u3067\\u30fc\\u305f",
"\\u30c7\\u30fc\\u30bf",
"\\u30c7\\u30a7\\u30bf",
"\\u3067\\u3048\\u305f",
"\\u30d2\\u30e5\\u30a6",
"\\u30d2\\u30e6\\u30a6",
"\\u30d4\\u30e5\\u30a6\\u30a2",
- "\\u3073\\u3085\\u30fc\\u3042\\u30fc",
+ "\\u3073\\u3085\\u30fc\\u3042\\u30fc",
"\\u30d3\\u30e5\\u30fc\\u30a2\\u30fc",
"\\u30d3\\u30e5\\u30a6\\u30a2\\u30fc",
"\\u3072\\u3085\\u3093",
const char *rules;
const char *data[50];
const uint32_t len;
- } tests[] = {
+ } tests[] = {
{ "&b=\\u00e4\\u00e4",
{ "b", "\\u00e4\\u00e4", "a\\u0308a\\u0308", "\\u00e4a\\u0308", "a\\u0308\\u00e4" }, 5},
{ "&b=\\u00C5",
const char *rules;
const char *data[50];
const uint32_t len;
- } tests[] = {
+ } tests[] = {
{ "&g <<< a"
"&[before 3]\\uff41 <<< x",
{"x", "\\uff41"}, 2 },
{ "&\\u30A7=\\u30A7=\\u3047=\\uff6a"
"&\\u30A8=\\u30A8=\\u3048=\\uff74"
- "&[before 3]\\u30a7<<<\\u30a9",
+ "&[before 3]\\u30a7<<<\\u30a9",
{"\\u30a9", "\\u30a7"}, 2 },
{ "&[before 3]\\u30a7<<<\\u30a9"
"&\\u30A7=\\u30A7=\\u3047=\\uff6a"
}
#if 0
- const char* rule1 =
+ const char* rule1 =
"&\\u30A7=\\u30A7=\\u3047=\\uff6a"
"&\\u30A8=\\u30A8=\\u3048=\\uff74"
"&[before 3]\\u30a7<<<\\u30c6|\\u30fc";
- const char* rule2 =
+ const char* rule2 =
"&[before 3]\\u30a7<<<\\u30c6|\\u30fc"
"&\\u30A7=\\u30A7=\\u3047=\\uff6a"
"&\\u30A8=\\u30A8=\\u3048=\\uff74";
const char* test[] = {
- "\\u30c6\\u30fc\\u30bf",
+ "\\u30c6\\u30fc\\u30bf",
"\\u30c6\\u30a7\\u30bf",
};
genericRulesStarter(rule1, 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 */
- {
+ {
UErrorCode status = U_ZERO_ERROR;
uint32_t i = 0;
UCollationElements *it = NULL;
}
static void TestPrefixCompose(void) {
- const char* rule1 =
+ const char* rule1 =
"&\\u30a7<<<\\u30ab|\\u30fc=\\u30ac|\\u30fc";
/*
const char* test[] = {
- "\\u30c6\\u30fc\\u30bf",
+ "\\u30c6\\u30fc\\u30bf",
"\\u30c6\\u30a7\\u30bf",
};
*/
- {
+ {
UErrorCode status = U_ZERO_ERROR;
/*uint32_t i = 0;*/
/*UCollationElements *it = NULL;*/
}
/*
-[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)
+[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)
*/
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 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[] = {
+ } tests[] = {
/* - all befores here amount to zero */
- { "&[before 1][first tertiary ignorable]<<<a",
- { "\\u0000", "a"}, 2}, /* you cannot go before first tertiary ignorable */
+ { "&[before 3][first tertiary ignorable]<<<a",
+ { "\\u0000", "a"}, 2
+ }, /* you cannot go before first tertiary ignorable */
- { "&[before 1][last tertiary ignorable]<<<a",
- { "\\u0000", "a"}, 2}, /* you cannot go before last tertiary ignorable */
+ { "&[before 3][last tertiary ignorable]<<<a",
+ { "\\u0000", "a"}, 2
+ }, /* you cannot go before last tertiary ignorable */
- { "&[before 1][first secondary ignorable]<<<a",
- { "\\u0000", "a"}, 2}, /* you cannot go before first secondary ignorable */
+ { "&[before 3][first secondary ignorable]<<<a",
+ { "\\u0000", "a"}, 2
+ }, /* you cannot go before first secondary ignorable */
- { "&[before 1][last secondary ignorable]<<<a",
- { "\\u0000", "a"}, 2}, /* you cannot go before first secondary ignorable */
+ { "&[before 3][last secondary ignorable]<<<a",
+ { "\\u0000", "a"}, 2
+ }, /* you cannot go before first secondary ignorable */
/* 'normal' befores */
- { "&[before 1][first primary ignorable]<<<c<<<b &[first primary ignorable]<a",
- { "c", "b", "\\u0332", "a" }, 4},
+ { "&[before 3][first primary ignorable]<<<c<<<b &[first primary ignorable]<a",
+ { "c", "b", "\\u0332", "a" }, 4
+ },
- /* we don't have a code point that corresponds to
+ /* we don't have a code point that corresponds to
* the last primary ignorable
*/
- { "&[before 2][last primary ignorable]<<<c<<<b &[last primary ignorable]<a",
- { "\\u0332", "\\u20e3", "c", "b", "a" }, 5},
+ { "&[before 3][last primary ignorable]<<<c<<<b &[last primary ignorable]<a",
+ { "\\u0332", "\\u20e3", "c", "b", "a" }, 5
+ },
- { "&[before 1][first variable]<<<c<<<b &[first variable]<a",
- { "c", "b", "\\u0009", "a", "\\u000a" }, 5},
+ { "&[before 3][first variable]<<<c<<<b &[first variable]<a",
+ { "c", "b", "\\u0009", "a", "\\u000a" }, 5
+ },
- { "&[last variable]<a &[before 1][last variable]<<<c<<<b ",
- { "c", "b", "\\uD800\\uDF23", "a", "\\u02d0" }, 5},
+ { "&[last variable]<a &[before 3][last variable]<<<c<<<b ",
+ { "c", "b", "\\uD800\\uDD33", "a", "\\u02d0" }, 5
+ },
{ "&[first regular]<a"
"&[before 1][first regular]<b",
- { "b", "\\u02d0", "a", "\\u02d1"}, 4},
+ { "b", "\\u02d0", "a", "\\u02d1"}, 4
+ },
{ "&[before 1][last regular]<b"
"&[last regular]<a",
- { "b", "\\uD801\\uDC25", "a", "\\u4e00" }, 4},
+ { "b", "\\uD800\\uDF9D", "a", "\\u4e00" }, 4
+ },
{ "&[before 1][first implicit]<b"
"&[first implicit]<a",
- { "b", "\\u4e00", "a", "\\u4e01"}, 4},
+ { "b", "\\u4e00", "a", "\\u4e01"}, 4
+ },
{ "&[before 1][last implicit]<b"
"&[last implicit]<a",
- { "b", "\\U0010FFFC", "a" }, 3},
+ { "b", "\\U0010FFFD", "a" }, 3
+ },
{ "&[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 }
+ {"\\ufffb", "w", "y", "\\u20e3", "x", "\\u137c", "z", "u"}, 7
+ }
};
uint32_t i;
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
+ /* 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[] = {
+ } tests[] = {
/* - all befores here amount to zero */
- { "[optimize [\\uAC00-\\uD7FF]]",
- { "a", "b"}, 2}
+ { "[optimize [\\uAC00-\\uD7FF]]",
+ { "a", "b"}, 2}
};
uint32_t i;
}
/*
-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
+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;
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];
+ 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;
UConverter *conv = NULL;
static void TestPartialSortKeyTermination(void) {
const char* cases[] = {
"\\u1234\\u1234\\udc00",
- "\\udc00\\ud800\\ud800"
+ "\\udc00\\ud800\\ud800"
};
int32_t i = sizeof(UCollator);
ucol_close(coll);
}
+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("Empty rules should have produced a valid collator\n");
+ } else {
+ ucol_close(coll);
+ }
+}
+
+/**
+ * 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;
+
+ 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",
+ };
+
+ const static char *thirtyTwoBitNumericStrings[]={
+ "avery42949672960",
+ "avery42949672961",
+ "avery42949672962",
+ "avery429496729610"
+ };
+
+ 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 *foreignDigits[] = {
+ "\\u0661",
+ "\\u0662",
+ "\\u0663",
+ "\\u0661\\u0660",
+ "\\u0661\\u0662",
+ "\\u0661\\u0663",
+ "\\u0662\\u0660",
+ "\\u0662\\u0662",
+ "\\u0662\\u0663",
+ "\\u0663\\u0660",
+ "\\u0663\\u0662",
+ "\\u0663\\u0663"
+ };
+
+ const static char *evenZeroes[] = {
+ "2000",
+ "2001",
+ "2002",
+ "2003"
+ };
+
+ UColAttribute att = UCOL_NUMERIC_COLLATION;
+ UColAttributeValue val = UCOL_ON;
+
+ /* 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));
+ 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));
+ 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(coll);
+}
+
+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_close(coll);
+
+ genericLocaleStarterWithResult("", test, 2, UCOL_EQUAL);
+}
+
+static void TestPinyinProblem(void) {
+ static const char *test[] = { "\\u4E56\\u4E56\\u7761", "\\u4E56\\u5B69\\u5B50" };
+ genericLocaleStarter("zh__PINYIN", test, sizeof(test)/sizeof(test[0]));
+}
+
+#define TST_UCOL_MAX_INPUT 0x220001
+#define topByte 0xFF000000;
+#define bottomByte 0xFF;
+#define fourBytes 0xFFFFFFFF;
+
+
+static void showImplicit(UChar32 i) {
+ if (i >= 0 && i <= TST_UCOL_MAX_INPUT) {
+ log_verbose("%08X\t%08X\n", i, uprv_uca_getImplicitFromRaw(i));
+ }
+}
+
+static void TestImplicitGeneration(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);
+ if(U_FAILURE(status)) {
+ log_err("Couldn't open UCA\n");
+ 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);
+ }
+ }
+ showImplicit(TST_UCOL_MAX_INPUT-2);
+ showImplicit(TST_UCOL_MAX_INPUT-1);
+ showImplicit(TST_UCOL_MAX_INPUT);
+ ucol_close(coll);
+}
+
+/**
+ * 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;
+
+ 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;
+ }
+ }
+ }
+ 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]);
+ }
+ }
+ return n;
+}
+
+/**
+ * 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 const char* AVAIL[] = { "en", "de" };
+
+ static const char* KW[] = { "collation" };
+
+ static const char* KWVAL[] = { "phonebook", "stroke" };
+
+#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
+
+ 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);
+
+ 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);
+
+ /* 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);
+
+ /*
+U_DRAFT int32_t U_EXPORT2
+ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,
+ const char* locale, UBool* isAvailable,
+ UErrorCode* status);
+}
+*/
+ 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);
+}
+
+/* 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"
+ };
+
+ 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]));
+}
+
+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 }
+ };
+
+ int32_t i = 0;
+
+ UErrorCode status = U_ZERO_ERROR;
+ UChar rlz[RULE_BUFFER_LEN] = { 0 };
+ uint32_t rlen = 0;
+
+ UCollator *coll = NULL;
+
+
+ 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));
+ }
+ ucol_close(coll);
+ status = U_ZERO_ERROR;
+ }
+
+}
+
+#if 0
+&m < a
+&[before 1] a < x <<< X << q <<< Q < z
+assert: m <<< M < x <<< X << q <<< Q < z < a < n
+
+&m < a
+&[before 2] a << x <<< X << q <<< Q < z
+assert: m <<< M < x <<< X << q <<< Q << a < z < n
+
+&m < a
+&[before 3] a <<< x <<< X << q <<< Q < z
+assert: m <<< M < x <<< X <<< a << q <<< Q < z < n
+
+
+&m << a
+&[before 1] a < x <<< X << q <<< Q < z
+assert: x <<< X << q <<< Q < z < m <<< M << a < n
+
+&m << a
+&[before 2] a << x <<< X << q <<< Q < z
+assert: m <<< M << x <<< X << q <<< Q << a < z < n
+
+&m << a
+&[before 3] a <<< x <<< X << q <<< Q < z
+assert: m <<< M << x <<< X <<< a << q <<< Q < z < n
+
+
+&m <<< a
+&[before 1] a < x <<< X << q <<< Q < z
+assert: x <<< X << q <<< Q < z < n < m <<< a <<< M
+
+&m <<< a
+&[before 2] a << x <<< X << q <<< Q < z
+assert: x <<< X << q <<< Q << m <<< a <<< M < z < n
+
+&m <<< a
+&[before 3] a <<< x <<< X << q <<< Q < z
+assert: m <<< x <<< X <<< a <<< M << q <<< Q < z < n
+
+
+&[before 1] s < x <<< X << q <<< Q < z
+assert: r <<< R < x <<< X << q <<< Q < z < s < n
+
+&[before 2] s << x <<< X << q <<< Q < z
+assert: r <<< R < x <<< X << q <<< Q << s < z < n
+
+&[before 3] s <<< x <<< X << q <<< Q < z
+assert: r <<< R < x <<< X <<< s << q <<< Q < z < n
+
+
+&[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
+#endif
+
+
+#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}
+ };
+
+ int32_t i = 0;
+
+ for(i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
+ genericRulesStarter(tests[i].rules, tests[i].order, tests[i].size);
+ }
+}
+#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);
+ res = ucol_strcoll(coll, &a, 1, &null, 1);
+ if(res != UCOL_LESS) {
+ log_err("NULL was not tailored properly!\n");
+ }
+ ucol_close(coll);
+}
#define TEST(x) addTest(root, &x, "tscoll/cmsccoll/" # x)
void addMiscCollTest(TestNode** root)
{
- addTest(root, &TestNumericCollation, "tscoll/cmsccoll/TestNumericCollation");
- addTest(root, &TestRuleOptions, "tscoll/cmsccoll/TestRuleOptions");
- addTest(root, &TestBeforePrefixFailure, "tscoll/cmsccoll/TestBeforePrefixFailure");
- addTest(root, &TestContractionClosure, "tscoll/cmsccoll/TestContractionClosure");
- addTest(root, &TestPrefixCompose, "tscoll/cmsccoll/TestPrefixCompose");
- addTest(root, &TestStrCollIdenticalPrefix, "tscoll/cmsccoll/TestStrCollIdenticalPrefix");
- addTest(root, &TestPrefix, "tscoll/cmsccoll/TestPrefix");
- addTest(root, &TestNewJapanese, "tscoll/cmsccoll/TestNewJapanese");
- /*addTest(root, &TestLimitations, "tscoll/cmsccoll/TestLimitations");*/
- addTest(root, &TestNonChars, "tscoll/cmsccoll/TestNonChars");
- addTest(root, &TestExtremeCompression, "tscoll/cmsccoll/TestExtremeCompression");
- addTest(root, &TestSurrogates, "tscoll/cmsccoll/TestSurrogates");
- addTest(root, &TestVariableTopSetting, "tscoll/cmsccoll/TestVariableTopSetting");
- addTest(root, &TestBocsuCoverage, "tscoll/cmsccoll/TestBocsuCoverage");
- addTest(root, &TestCyrillicTailoring, "tscoll/cmsccoll/TestCyrillicTailoring");
- addTest(root, &TestCase, "tscoll/cmsccoll/TestCase");
- addTest(root, &IncompleteCntTest, "tscoll/cmsccoll/IncompleteCntTest");
- addTest(root, &BlackBirdTest, "tscoll/cmsccoll/BlackBirdTest");
- addTest(root, &FunkyATest, "tscoll/cmsccoll/FunkyATest");
- addTest(root, &BillFairmanTest, "tscoll/cmsccoll/BillFairmanTest");
- addTest(root, &RamsRulesTest, "tscoll/cmsccoll/RamsRulesTest");
- addTest(root, &IsTailoredTest, "tscoll/cmsccoll/IsTailoredTest");
- addTest(root, &TestCollations, "tscoll/cmsccoll/TestCollations");
- addTest(root, &TestChMove, "tscoll/cmsccoll/TestChMove");
- addTest(root, &TestImplicitTailoring, "tscoll/cmsccoll/TestImplicitTailoring");
- addTest(root, &TestFCDProblem, "tscoll/cmsccoll/TestFCDProblem");
- addTest(root, &TestEmptyRule, "tscoll/cmsccoll/TestEmptyRule");
- addTest(root, &TestJ784, "tscoll/cmsccoll/TestJ784");
- addTest(root, &TestJ815, "tscoll/cmsccoll/TestJ815");
- addTest(root, &TestJ831, "tscoll/cmsccoll/TestJ831");
- addTest(root, &TestBefore, "tscoll/cmsccoll/TestBefore");
- addTest(root, &TestRedundantRules, "tscoll/cmsccoll/TestRedundantRules");
- addTest(root, &TestExpansionSyntax, "tscoll/cmsccoll/TestExpansionSyntax");
- addTest(root, &TestHangulTailoring, "tscoll/cmsccoll/TestHangulTailoring");
- addTest(root, &TestUCARules, "tscoll/cmsccoll/TestUCARules");
- addTest(root, &TestIncrementalNormalize, "tscoll/cmsccoll/TestIncrementalNormalize");
- addTest(root, &TestComposeDecompose, "tscoll/cmsccoll/TestComposeDecompose");
- addTest(root, &TestCompressOverlap, "tscoll/cmsccoll/TestCompressOverlap");
- addTest(root, &TestContraction, "tscoll/cmsccoll/TestContraction");
- addTest(root, &TestExpansion, "tscoll/cmsccoll/TestExpansion");
- /*addTest(root, &PrintMarkDavis, "tscoll/cmsccoll/PrintMarkDavis");*/ /* this test doesn't test - just prints sortkeys */
- /*addTest(root, &TestGetCaseBit, "tscoll/cmsccoll/TestGetCaseBit");*/ /*this one requires internal things to be exported */
+ TEST(TestRuleOptions);
+ TEST(TestBeforePrefixFailure);
+ TEST(TestContractionClosure);
+ TEST(TestPrefixCompose);
+ TEST(TestStrCollIdenticalPrefix);
+ TEST(TestPrefix);
+ TEST(TestNewJapanese);
+ /*TEST(TestLimitations);*/
+ TEST(TestNonChars);
+ TEST(TestExtremeCompression);
+ TEST(TestSurrogates);
+ TEST(TestVariableTopSetting);
+ TEST(TestBocsuCoverage);
+ TEST(TestCyrillicTailoring);
+ TEST(TestCase);
+ TEST(IncompleteCntTest);
+ 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(TestBefore);
+ TEST(TestRedundantRules);
+ TEST(TestExpansionSyntax);
+ TEST(TestHangulTailoring);
+ TEST(TestUCARules);
+ TEST(TestIncrementalNormalize);
+ TEST(TestComposeDecompose);
+ TEST(TestCompressOverlap);
+ TEST(TestContraction);
+ TEST(TestExpansion);
+ /*TEST(PrintMarkDavis);*/ /* this test doesn't test - just prints sortkeys */
+ /*TEST(TestGetCaseBit);*/ /*this one requires internal things to be exported */
TEST(TestOptimize);
TEST(TestSuppressContractions);
TEST(Alexis2);
TEST(TestSettings);
TEST(TestEquals);
TEST(TestJ2726);
+ TEST(NullRule);
+ TEST(TestNumericCollation);
+ TEST(TestTibetanConformance);
+ TEST(TestPinyinProblem);
+ TEST(TestImplicitGeneration);
+ TEST(TestSeparateTrees);
+ TEST(TestBeforePinyin);
+ TEST(TestBeforeTightening);
+ /*TEST(TestMoreBefore);*/
+ TEST(TestTailorNULL);
}
#endif /* #if !UCONFIG_NO_COLLATION */
+
projects / apple / icu.git / blobdiff