blob: 66b389e6a74074e9f731202f8910dac5c162e0fb [file] [log] [blame]
/********************************************************************
* COPYRIGHT:
* Copyright (c) 2001-2011, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
/*******************************************************************************
*
* File cmsccoll.C
*
*******************************************************************************/
/**
* These are the tests specific to ICU 1.8 and above, that I didn't know where
* to fit.
*/
#include <stdio.h>
#include "unicode/utypes.h"
#if !UCONFIG_NO_COLLATION
#include "unicode/ucol.h"
#include "unicode/ucoleitr.h"
#include "unicode/uloc.h"
#include "cintltst.h"
#include "ccolltst.h"
#include "callcoll.h"
#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 "uparse.h"
#include "putilimp.h"
#define LEN(a) (sizeof(a)/sizeof(a[0]))
#define MAX_TOKEN_LEN 16
typedef UCollationResult tst_strcoll(void *collator, const int object,
const UChar *source, const int sLen,
const UChar *target, const int tLen);
const static char cnt1[][10] = {
"AA",
"AC",
"AZ",
"AQ",
"AB",
"ABZ",
"ABQ",
"Z",
"ABC",
"Q",
"B"
};
const static char cnt2[][10] = {
"DA",
"DAD",
"DAZ",
"MAR",
"Z",
"DAVIS",
"MARK",
"DAV",
"DAVI"
};
static void IncompleteCntTest(void)
{
UErrorCode status = U_ZERO_ERROR;
UChar temp[90];
UChar t1[90];
UChar t2[90];
UCollator *coll = NULL;
uint32_t i = 0, j = 0;
uint32_t size = 0;
u_uastrcpy(temp, " & Z < ABC < Q < B");
coll = ucol_openRules(temp, u_strlen(temp), UCOL_OFF, UCOL_DEFAULT_STRENGTH, NULL,&status);
if(U_SUCCESS(status)) {
size = sizeof(cnt1)/sizeof(cnt1[0]);
for(i = 0; i < size-1; i++) {
for(j = i+1; j < size; j++) {
UCollationElements *iter;
u_uastrcpy(t1, cnt1[i]);
u_uastrcpy(t2, cnt1[j]);
doTest(coll, t1, t2, UCOL_LESS);
/* synwee : added collation element iterator test */
iter = ucol_openElements(coll, t2, u_strlen(t2), &status);
if (U_FAILURE(status)) {
log_err("Creation of iterator failed\n");
break;
}
backAndForth(iter);
ucol_closeElements(iter);
}
}
}
ucol_close(coll);
u_uastrcpy(temp, " & Z < DAVIS < MARK <DAV");
coll = ucol_openRules(temp, u_strlen(temp), UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL, &status);
if(U_SUCCESS(status)) {
size = sizeof(cnt2)/sizeof(cnt2[0]);
for(i = 0; i < size-1; i++) {
for(j = i+1; j < size; j++) {
UCollationElements *iter;
u_uastrcpy(t1, cnt2[i]);
u_uastrcpy(t2, cnt2[j]);
doTest(coll, t1, t2, UCOL_LESS);
/* synwee : added collation element iterator test */
iter = ucol_openElements(coll, t2, u_strlen(t2), &status);
if (U_FAILURE(status)) {
log_err("Creation of iterator failed\n");
break;
}
backAndForth(iter);
ucol_closeElements(iter);
}
}
}
ucol_close(coll);
}
const static char shifted[][20] = {
"black bird",
"black-bird",
"blackbird",
"black Bird",
"black-Bird",
"blackBird",
"black birds",
"black-birds",
"blackbirds"
};
const static UCollationResult shiftedTert[] = {
UCOL_EQUAL,
UCOL_EQUAL,
UCOL_EQUAL,
UCOL_LESS,
UCOL_EQUAL,
UCOL_EQUAL,
UCOL_LESS,
UCOL_EQUAL,
UCOL_EQUAL
};
const static char nonignorable[][20] = {
"black bird",
"black Bird",
"black birds",
"black-bird",
"black-Bird",
"black-birds",
"blackbird",
"blackBird",
"blackbirds"
};
static void BlackBirdTest(void) {
UErrorCode status = U_ZERO_ERROR;
UChar t1[90];
UChar t2[90];
uint32_t i = 0, j = 0;
uint32_t size = 0;
UCollator *coll = ucol_open("en_US", &status);
ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_OFF, &status);
ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, &status);
if(U_SUCCESS(status)) {
size = sizeof(nonignorable)/sizeof(nonignorable[0]);
for(i = 0; i < size-1; i++) {
for(j = i+1; j < size; j++) {
u_uastrcpy(t1, nonignorable[i]);
u_uastrcpy(t2, nonignorable[j]);
doTest(coll, t1, t2, UCOL_LESS);
}
}
}
ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_QUATERNARY, &status);
if(U_SUCCESS(status)) {
size = sizeof(shifted)/sizeof(shifted[0]);
for(i = 0; i < size-1; i++) {
for(j = i+1; j < size; j++) {
u_uastrcpy(t1, shifted[i]);
u_uastrcpy(t2, shifted[j]);
doTest(coll, t1, t2, UCOL_LESS);
}
}
}
ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_TERTIARY, &status);
if(U_SUCCESS(status)) {
size = sizeof(shifted)/sizeof(shifted[0]);
for(i = 1; i < size; i++) {
u_uastrcpy(t1, shifted[i-1]);
u_uastrcpy(t2, shifted[i]);
doTest(coll, t1, t2, shiftedTert[i]);
}
}
ucol_close(coll);
}
const static UChar testSourceCases[][MAX_TOKEN_LEN] = {
{0x0041/*'A'*/, 0x0300, 0x0301, 0x0000},
{0x0041/*'A'*/, 0x0300, 0x0316, 0x0000},
{0x0041/*'A'*/, 0x0300, 0x0000},
{0x00C0, 0x0301, 0x0000},
/* this would work with forced normalization */
{0x00C0, 0x0316, 0x0000}
};
const static UChar testTargetCases[][MAX_TOKEN_LEN] = {
{0x0041/*'A'*/, 0x0301, 0x0300, 0x0000},
{0x0041/*'A'*/, 0x0316, 0x0300, 0x0000},
{0x00C0, 0},
{0x0041/*'A'*/, 0x0301, 0x0300, 0x0000},
/* this would work with forced normalization */
{0x0041/*'A'*/, 0x0316, 0x0300, 0x0000}
};
const static UCollationResult results[] = {
UCOL_GREATER,
UCOL_EQUAL,
UCOL_EQUAL,
UCOL_GREATER,
UCOL_EQUAL
};
static void FunkyATest(void)
{
int32_t i;
UErrorCode status = U_ZERO_ERROR;
UCollator *myCollation;
myCollation = ucol_open("en_US", &status);
if(U_FAILURE(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");
ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
ucol_setStrength(myCollation, UCOL_TERTIARY);
for (i = 0; i < 4 ; i++)
{
doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
}
ucol_close(myCollation);
}
UColAttributeValue caseFirst[] = {
UCOL_OFF,
UCOL_LOWER_FIRST,
UCOL_UPPER_FIRST
};
UColAttributeValue alternateHandling[] = {
UCOL_NON_IGNORABLE,
UCOL_SHIFTED
};
UColAttributeValue caseLevel[] = {
UCOL_OFF,
UCOL_ON
};
UColAttributeValue strengths[] = {
UCOL_PRIMARY,
UCOL_SECONDARY,
UCOL_TERTIARY,
UCOL_QUATERNARY,
UCOL_IDENTICAL
};
#if 0
static const char * strengthsC[] = {
"UCOL_PRIMARY",
"UCOL_SECONDARY",
"UCOL_TERTIARY",
"UCOL_QUATERNARY",
"UCOL_IDENTICAL"
};
static const char * caseFirstC[] = {
"UCOL_OFF",
"UCOL_LOWER_FIRST",
"UCOL_UPPER_FIRST"
};
static const char * alternateHandlingC[] = {
"UCOL_NON_IGNORABLE",
"UCOL_SHIFTED"
};
static const char * caseLevelC[] = {
"UCOL_OFF",
"UCOL_ON"
};
/* not used currently - does not test only prints */
static void PrintMarkDavis(void)
{
UErrorCode status = U_ZERO_ERROR;
UChar m[256];
uint8_t sortkey[256];
UCollator *coll = ucol_open("en_US", &status);
uint32_t h,i,j,k, sortkeysize;
uint32_t sizem = 0;
char buffer[512];
uint32_t len = 512;
log_verbose("PrintMarkDavis");
u_uastrcpy(m, "Mark Davis");
sizem = u_strlen(m);
m[1] = 0xe4;
for(i = 0; i<sizem; i++) {
fprintf(stderr, "\\u%04X ", m[i]);
}
fprintf(stderr, "\n");
for(h = 0; h<sizeof(caseFirst)/sizeof(caseFirst[0]); 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++) {
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++) {
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++) {
ucol_setAttribute(coll, UCOL_STRENGTH, strengths[k], &status);
sortkeysize = ucol_getSortKey(coll, m, sizem, sortkey, 256);
fprintf(stderr, " strength: %s\n Sortkey: ", strengthsC[k]);
fprintf(stderr, "%s\n", ucol_sortKeyToString(coll, sortkey, buffer, &len));
}
}
}
}
}
#endif
static void BillFairmanTest(void) {
/*
** check for actual locale via ICU resource bundles
**
** lp points to the original locale ("fr_FR_....")
*/
UResourceBundle *lr,*cr;
UErrorCode lec = U_ZERO_ERROR;
const char *lp = "fr_FR_you_ll_never_find_this_locale";
log_verbose("BillFairmanTest\n");
lr = ures_open(NULL,lp,&lec);
if (lr) {
cr = ures_getByKey(lr,"collations",0,&lec);
if (cr) {
lp = ures_getLocaleByType(cr, ULOC_ACTUAL_LOCALE, &lec);
if (lp) {
if (U_SUCCESS(lec)) {
if(strcmp(lp, "fr") != 0) {
log_err("Wrong locale for French Collation Data, expected \"fr\" got %s", lp);
}
}
}
ures_close(cr);
}
ures_close(lr);
}
}
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");*/
doTest(col, p, q, UCOL_LESS);
/*
UCollationResult result = ucol_strcoll(col,p,u_strlen(p),q,u_strlen(q));
if(result!=UCOL_LESS){
aescstrdup(p,utfSource,256);
aescstrdup(q,utfTarget,256);
fprintf(file,"Primary failed source: %s target: %s \n", utfSource,utfTarget);
}
*/
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);
*/
}
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);
*/
u_strcpy(source,p);
source[u_strlen(p)] = 0x62;
source[u_strlen(p)+1] = 0;
u_strcpy(target,q);
target[u_strlen(q)] = 0x61;
target[u_strlen(q)+1] = 0;
doTest(col, source, target, UCOL_GREATER);
/*
fprintf(file,"secondary is swamped by 1 failed source: %s target: %s \n",utfSource,utfTarget);
*/
}
static void testTertiary(UCollator* col, const UChar* p,const UChar* q){
UChar source[256] = { '\0'};
UChar target[256] = { '\0'};
/*log_verbose("Testing tertiary\n");*/
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);
doTest(col, source, target, UCOL_LESS);
/*
fprintf(file,"Tertiary swamps 4th failed source: %s target: %s \n", utfSource,utfTarget);
*/
u_strcpy(source,p);
source[u_strlen(p)] = 0xE0;
source[u_strlen(p)+1] = 0;
u_strcpy(target,q);
target[u_strlen(q)] = 0x61;
target[u_strlen(q)+1] = 0;
doTest(col, source, target, UCOL_GREATER);
/*
fprintf(file,"Tertiary is swamped by 3rd failed source: %s target: %s \n",utfSource,utfTarget);
*/
}
static void testEquality(UCollator* col, const UChar* p,const UChar* q){
/*
UChar source[256] = { '\0'};
UChar target[256] = { '\0'};
*/
doTest(col, p, q, UCOL_EQUAL);
/*
fprintf(file,"Primary failed source: %s target: %s \n", utfSource,utfTarget);
*/
}
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;
}
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);
tempLen = firstLen;
firstLen = chLen;
chLen = tempLen;
tempLen = firstEx;
firstEx = exLen;
exLen = tempLen;
if(beforeStrength < strength) {
strength = beforeStrength;
}
}
}
lastReset = FALSE;
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;
}
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);
}
}
free(rulesCopy);
}
}
static UCollationResult 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);
}
/*
static UCollationResult winTest(void *collator, const int object, const UChar *source, const int sLen, const UChar *target, const int tLen) {
#ifdef U_WINDOWS
LCID lcid = (LCID)collator;
return (UCollationResult)CompareString(lcid, 0, source, sLen, target, tLen);
#else
return 0;
#endif
}
*/
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};
source[0] = s1;
u_strcpy(source+1, s);
target[0] = s2;
u_strcpy(target+1, t);
return func(collator, opts, source, sLen+1, target, tLen+1);
}
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;
return func(collator, opts, source, sLen+1, target, tLen+1);
}
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;
}
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;
}
}
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';
} else {
for(i = 0; i<strength+1; i++) {
buffer[i] = '<';
}
buffer[strength+1] = '\0';
}
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 int32_t maxOutputLength = 0;
int32_t 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);
}
}
/*
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, " ]] ");
log_verbose("%s", output);
*/
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 = (int32_t)strlen(output);
if(outputLength > maxOutputLength) {
maxOutputLength = outputLength;
U_ASSERT(outputLength < sizeof(output));
}
log_verbose("%s\n", output);
}
/*
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;
}
}
log_verbose("\n");
}
*/
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);
realResult = func(collator, opts, first, sLen, second, tLen);
realStrength = probeStrength(func, collator, opts, first, sLen, second, tLen, realResult);
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;
}
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(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");*/
}
}
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");
}
free(rulesCopy);
}
}
/*
* 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;
}
}
}
}
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 = uprv_new_collIterate(status);
UCAConstants *consts = NULL;
uint32_t UCOL_RESET_TOP_VALUE, /*UCOL_RESET_TOP_CONT, */
UCOL_NEXT_TOP_VALUE, UCOL_NEXT_TOP_CONT;
const char *colLoc;
UCollator *UCA = ucol_open("root", status);
if (U_FAILURE(*status)) {
log_err("Could not open root collator %s\n", u_errorName(*status));
uprv_delete_collIterate(c);
return;
}
colLoc = ucol_getLocaleByType(coll, ULOC_ACTUAL_LOCALE, status);
if (U_FAILURE(*status)) {
log_err("Could not get collator name: %s\n", u_errorName(*status));
ucol_close(UCA);
uprv_delete_collIterate(c);
return;
}
consts = (UCAConstants *)((uint8_t *)UCA->image + UCA->image->UCAConsts);
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;
}
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, status);
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);
}
currContCE = ucol_getNextCE(coll, c, status);
if(!isContinuation(currContCE)) {
currContCE = 0;
}
/* we need to repack CEs here */
if(strength == UCOL_TOK_RESET) {
before = (UBool)((specs & UCOL_TOK_BEFORE) != 0);
if(top_ == TRUE) {
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;
}
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("%s: couldn't find the CE\n", colLoc);
return;
}
}
}
currCE &= 0xFFFFFF3F;
currContCE &= 0xFFFFFFBF;
if(maxStrength == UCOL_IDENTICAL) {
if(baseCE != currCE || baseContCE != currContCE) {
log_err("%s: current CE (initial strength UCOL_EQUAL)\n", colLoc);
}
} else {
if(strength == UCOL_IDENTICAL) {
if(lastCE != currCE || lastContCE != currContCE) {
log_err("%s: current CE (initial strength UCOL_EQUAL)\n", colLoc);
}
} else {
if(compareCEs(currCE, currContCE, nextCE, nextContCE) > 0) {
/*if(currCE > nextCE || (currCE == nextCE && currContCE >= nextContCE)) {*/
log_err("%s: current CE is not less than base CE\n", colLoc);
}
if(!before) {
if(compareCEs(currCE, currContCE, lastCE, lastContCE) < 0) {
/*if(currCE < lastCE || (currCE == lastCE && currContCE <= lastContCE)) {*/
log_err("%s: sequence of generated CEs is broken\n", colLoc);
}
} else {
before = FALSE;
if(compareCEs(currCE, currContCE, lastCE, lastContCE) > 0) {
/*if(currCE < lastCE || (currCE == lastCE && currContCE <= lastContCE)) {*/
log_err("%s: sequence of generated CEs is broken\n", colLoc);
}
}
}
}
}
oldOffset = chOffset;
lastCE = currCE & 0xFFFFFF3F;
lastContCE = currContCE & 0xFFFFFFBF;
}
free(rulesCopy);
}
ucol_close(UCA);
uprv_delete_collIterate(c);
}
#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
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"*/
};
static void TestCollations(void) {
int32_t noOfLoc = uloc_countAvailable();
int32_t i = 0, j = 0;
UErrorCode status = U_ZERO_ERROR;
char cName[256];
UChar name[256];
int32_t nameSize;
const char *locName = NULL;
UCollator *coll = NULL;
UCollator *UCA = ucol_open("", &status);
UColAttributeValue oldStrength = ucol_getAttribute(UCA, UCOL_STRENGTH, &status);
if (U_FAILURE(status)) {
log_err_status(status, "Could not open UCA collator %s\n", u_errorName(status));
return;
}
ucol_setAttribute(UCA, UCOL_STRENGTH, UCOL_QUATERNARY, &status);
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];
}
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;
}
}
}
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");
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;
}
if (uprv_strcmp("km", locName)==0 ||
uprv_strcmp("km_KH", locName)==0 ||
uprv_strcmp("si", locName)==0 ||
uprv_strcmp("si_LK", locName)==0 ||
uprv_strcmp("zh", locName)==0 ||
uprv_strcmp("zh_Hant", locName)==0 ) {
continue; /* TODO: enable these locale tests after trac#6040 is fixed. */
}
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);
}
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);
}
}
}
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;
log_verbose("IsTailoredTest\n");
u_uastrcpy(rule, "&Z < A, B, C;c < d");
ruleLen = u_strlen(rule);
u_uastrcpy(tailored, "ABCcd");
tailoredLen = u_strlen(tailored);
u_uastrcpy(notTailored, "ZabD");
notTailoredLen = u_strlen(notTailored);
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]);
}
}
ucol_close(coll);
}
else {
log_err_status(status, "Can't tailor rules\n");
}
/* Code coverage */
status = U_ZERO_ERROR;
coll = ucol_open("ja", &status);
if(!ucol_isTailored(coll, 0x4E9C, &status)) {
log_err_status(status, "0x4E9C should be tailored - it is reported as not\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};
uint32_t i = 0, j = 0;
uint32_t size = 0;
UErrorCode status = U_ZERO_ERROR;
UCollator *coll = ucol_open("cs", &status);
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);
}
}
}
else {
log_err("Can't open collator");
}
ucol_close(coll);
}
const static char impTest[][20] = {
"\\u4e00",
"a",
"A",
"b",
"B",
"\\u4e01"
};
static void TestImplicitTailoring(void) {
static const struct {
const char *rules;
const char *data[10];
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};
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);
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");
}
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);
}
/*
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;
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;
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;
noOfLoc = uloc_countAvailable();
coll = ucol_open("", &status);
if (U_FAILURE(status)) {
log_data_err("Error opening collator -> %s (Are you missing data?)\n", u_errorName(status));
return;
}
charsToTestSize = uset_size(charsToTest);
if (charsToTestSize <= 0) {
log_err("Set was zero. Missing data?\n");
return;
}
t = malloc(charsToTestSize * sizeof(tester *));
t[0] = (tester *)malloc(sizeof(tester));
log_verbose("Testing UCA extensively for %d characters\n", charsToTestSize);
for(u = 0; u < charsToTestSize; u++) {
UChar32 ch = uset_charAt(charsToTest, u);
len = 0;
UTF_APPEND_CHAR_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);
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));
}
}
log_verbose("Testing %d/%d of possible test cases\n", noCases, charsToTestSize);
uset_close(charsToTest);
charsToTest = NULL;
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);
}
}
/*
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;
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);
}
*/
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);
for(j = 0; j<nameSize; j++) {
cName[j] = (char)name[j];
}
cName[nameSize] = 0;
log_verbose("\nTesting locale %s (%s)\n", locName, cName);
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);
}
}
for(u = 0; u <= (UChar32)noCases; u++) {
free(t[u]);
}
free(t);
}
static void TestEmptyRule(void) {
UErrorCode status = U_ZERO_ERROR;
UChar rulez[] = { 0 };
UCollator *coll = ucol_openRules(rulez, 0, UCOL_OFF, UCOL_TERTIARY,NULL, &status);
ucol_close(coll);
}
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);
log_verbose("TestUCARules\n");
if(ruleLen > 256) {
rules = (UChar *)malloc((ruleLen+1)*sizeof(UChar));
ruleLen = ucol_getRulesEx(coll, UCOL_FULL_RULES, rules, ruleLen);
}
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 {
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);
}
}
/* 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)
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]));
}
#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, 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",
"i",
"Y",
"y"
};
genericLocaleStarter("lv", data, sizeof(data)/sizeof(data[0]));
}
#endif
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, sizeof(data)/sizeof(data[0]));
genericRulesStarter("[backwards 2]&A<<\\u00e6/e<<<\\u00c6/E", data, sizeof(data)/sizeof(data[0]));
}
/*
"& 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;
static const 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(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) {
log_data_err("Is your data around?\n");
return;
} else if(U_FAILURE(status)) {
log_err("Error opening collator\n");
return;
}
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);
ucol_close(credundant);
ucol_close(cresulting);
log_verbose("testing using data\n");
genericRulesStarter(tests[i].rules, tests[i].testdata, tests[i].testdatalen);
}
}
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
};
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);
/* 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);
ucol_close(credundant);
ucol_close(cresulting);
log_verbose("testing using data\n");
genericRulesStarter(rules[i], testdata[i], testdatalen[i]);
}
}
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 };
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}
};
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);
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);
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);
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);
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, 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]));
}
}
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;
UCollator *coll;
UErrorCode status = U_ZERO_ERROR;
UCollationResult result;
int32_t myQ = QUICK;
if(QUICK < 0) {
QUICK = 1;
}
{
/* Test 1. Run very long unnormalized strings, to force overflow of*/
/* most buffers along the way.*/
UChar strA[MAXSLEN+1];
UChar strB[MAXSLEN+1];
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;
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);
}
}
QUICK = myQ;
/* 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);
}
/* 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
* 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 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;
/* 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));
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");
}
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");
}
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);
}
/* Test 5: Null characters in non-normal source strings.*/
{
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_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");
}
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));
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);
}
/* Test 6: Null character as base of a non-normal combining sequence.*/
{
static const UChar strA[] = {0x41, 0x0, 0x300, 0x316, 0x41, 0x302, 0x00};
static const UChar strB[] = {0x41, 0x0, 0x302, 0x316, 0x41, 0x300, 0x00};
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);
}
#if 0
static void TestGetCaseBit(void) {
static const char *caseBitData[] = {
"a", "A", "ch", "Ch", "CH",
"\\uFF9E", "\\u0009"
};
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
};
uint32_t i, blen = 0;
UChar b[256] = {0};
UErrorCode status = U_ZERO_ERROR;
UCollator *UCA = ucol_open("", &status);
uint8_t res = 0;
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]);
}
}
}
#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";
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;
}
log_verbose("Using start of korean rules\n");
if(U_SUCCESS(status)) {
genericOrderingTest(coll, koreanData, sizeof(koreanData)/sizeof(koreanData[0]));
} else {
log_err("Unable to open collator with rules %s\n", rules);
}
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]));
ucol_close(coll);
log_verbose("Using ko__LOTUS locale\n");
genericLocaleStarter("ko__LOTUS", koreanData, sizeof(koreanData)/sizeof(koreanData[0]));
}
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;
coll = ucol_open("", &status);