837 lines
21 KiB
C
837 lines
21 KiB
C
/********************************************************************
|
|
* COPYRIGHT:
|
|
* Copyright (c) 2001, 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 <stdlib.h>
|
|
#include <stdio.h>
|
|
#include "unicode/utypes.h"
|
|
#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"
|
|
|
|
static UCollator *myCollation;
|
|
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, 0, UCOL_LESS, UCOL_LESS, 0, 0, UCOL_LESS },
|
|
{ UCOL_GREATER, UCOL_LESS, UCOL_LESS, 0, UCOL_LESS, UCOL_LESS, 0, 0, UCOL_GREATER },
|
|
{ UCOL_LESS, UCOL_LESS, UCOL_LESS, 0, UCOL_GREATER, UCOL_LESS, 0, 0, UCOL_LESS },
|
|
{ UCOL_GREATER, UCOL_LESS, UCOL_GREATER, 0, UCOL_LESS, UCOL_LESS, 0, 0, UCOL_GREATER }
|
|
|
|
};
|
|
|
|
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}
|
|
|
|
};
|
|
|
|
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 TestCase( )
|
|
{
|
|
int32_t i,j,k;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
myCollation = ucol_open("en_US", &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\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++) {
|
|
doTest(myCollation, testCase[i], testCase[j], caseTestResults[k][3*i+j-1]);
|
|
}
|
|
}
|
|
}
|
|
ucol_close(myCollation);
|
|
|
|
myCollation = ucol_openRules(gRules, u_strlen(gRules), UNORM_NONE, UCOL_TERTIARY, &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++) {
|
|
doTest(myCollation, testCase[i], testCase[j], caseTestResults[k][3*i+j-1]);
|
|
}
|
|
}
|
|
}
|
|
ucol_close(myCollation);
|
|
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
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);
|
|
}
|
|
|
|
static void IncompleteCntTest( )
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UChar *temp=(UChar*)malloc(sizeof(UChar) * 90);
|
|
UChar *t1 =(UChar*)malloc(sizeof(UChar) * 90);
|
|
UChar *t2 =(UChar*)malloc(sizeof(UChar) * 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_NO_NORMALIZATION,
|
|
UCOL_DEFAULT_STRENGTH, &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);
|
|
free(iter);
|
|
}
|
|
}
|
|
}
|
|
|
|
ucol_close(coll);
|
|
|
|
|
|
u_uastrcpy(temp, " & Z < DAVIS < MARK <DAV");
|
|
coll = ucol_openRules(temp, u_strlen(temp), UCOL_NO_NORMALIZATION,
|
|
UCOL_DEFAULT_STRENGTH, &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);
|
|
free(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[] = {
|
|
0,
|
|
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( ) {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UChar *t1 =(UChar*)malloc(sizeof(UChar) * 90);
|
|
UChar *t2 =(UChar*)malloc(sizeof(UChar) * 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( )
|
|
{
|
|
|
|
int32_t i;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
myCollation = ucol_open("en_US", &status);
|
|
if(U_FAILURE(status)){
|
|
log_err("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
|
|
};
|
|
|
|
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"
|
|
};
|
|
|
|
static const char * strengthsC[] = {
|
|
"UCOL_PRIMARY",
|
|
"UCOL_SECONDARY",
|
|
"UCOL_TERTIARY",
|
|
"UCOL_QUATERNARY",
|
|
"UCOL_IDENTICAL"
|
|
};
|
|
|
|
|
|
static void PrintMarkDavis( )
|
|
{
|
|
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));
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
static void BillFairmanTest( ) {
|
|
/*
|
|
** 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");
|
|
|
|
if ((lr = ures_open(NULL,lp,&lec))) {
|
|
if ((cr = ures_getByKey(lr,"CollationElements",0,&lec))) {
|
|
if ((lp = ures_getLocale(cr,&lec))) {
|
|
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'};
|
|
|
|
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] = 0x0491;
|
|
u_strcpy(source+1,p);
|
|
target[0] = 0x0413;
|
|
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'};
|
|
|
|
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'};
|
|
|
|
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 rExpsLen = 0; */
|
|
uint32_t firstLen = 0;
|
|
UBool varT = FALSE; UBool top_ = TRUE;
|
|
UBool startOfRules = TRUE;
|
|
UColTokenParser src;
|
|
UCATableHeader img;
|
|
|
|
UChar first[256];
|
|
UChar second[256];
|
|
UChar *rulesCopy = NULL;
|
|
|
|
src.image = &img;
|
|
|
|
rules = ucol_getRules(coll, &ruleLen);
|
|
if(U_SUCCESS(*status) && ruleLen > 0) {
|
|
rulesCopy = (UChar *)uprv_malloc((ruleLen+UCOL_TOK_EXTRA_RULE_SPACE_SIZE)*sizeof(UChar));
|
|
uprv_memcpy(rulesCopy, rules, ruleLen*sizeof(UChar));
|
|
src.source = src.current = 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, &strength,
|
|
&chOffset, &chLen, &exOffset, &exLen,
|
|
&varT, &top_, startOfRules, status)) != NULL) {
|
|
startOfRules = FALSE;
|
|
|
|
u_strncpy(second,rulesCopy+chOffset, chLen);
|
|
second[chLen] = 0;
|
|
|
|
if(exLen > 0) {
|
|
u_strncat(first, rulesCopy+exOffset, exLen);
|
|
first[firstLen+exLen] = 0;
|
|
}
|
|
|
|
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:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
firstLen = chLen;
|
|
u_strcpy(first, second);
|
|
|
|
}
|
|
uprv_free(rulesCopy);
|
|
}
|
|
}
|
|
|
|
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"
|
|
};
|
|
|
|
static const char* rulesToTest[] = {
|
|
"& Z < p, P",
|
|
"& abe < d < b < e",
|
|
"& a < d/be < b < e"
|
|
};
|
|
|
|
static void RamsRulesTest( ) {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
uint32_t i = 0;
|
|
UCollator *coll = NULL;
|
|
UChar rule[2048];
|
|
uint32_t ruleLen;
|
|
|
|
log_verbose("RamsRulesTest\n");
|
|
|
|
for(i = 0; i<sizeof(localesToTest)/sizeof(localesToTest[0]); i++) {
|
|
coll = ucol_open(localesToTest[i], &status);
|
|
log_verbose("Testing locale: %s\n", localesToTest[i]);
|
|
if(U_SUCCESS(status)) {
|
|
testCollator(coll, &status);
|
|
ucol_close(coll);
|
|
}
|
|
}
|
|
|
|
for(i = 0; i<sizeof(rulesToTest)/sizeof(rulesToTest[0]); i++) {
|
|
log_verbose("Testing rule: %s\n", rulesToTest[i]);
|
|
u_uastrcpy(rule, rulesToTest[i]);
|
|
ruleLen = u_strlen(rule);
|
|
coll = ucol_openRules(rule, ruleLen, UCOL_NO_NORMALIZATION, UCOL_TERTIARY, &status);
|
|
if(U_SUCCESS(status)) {
|
|
testCollator(coll, &status);
|
|
ucol_close(coll);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void IsTailoredTest( ) {
|
|
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_NO_NORMALIZATION, UCOL_TERTIARY, &status);
|
|
if(U_SUCCESS(status)) {
|
|
for(i = 0; i<tailoredLen; i++) {
|
|
if(!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(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);
|
|
}
|
|
}
|
|
|
|
void addMiscCollTest(TestNode** root)
|
|
{
|
|
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, &PrintMarkDavis, "tscoll/cmsccoll/PrintMarkDavis");*/
|
|
}
|
|
|