| OLD | NEW |
|---|
| (Empty) |
| 1 /******************************************************************** | |
| 2 * COPYRIGHT: | |
| 3 * Copyright (c) 1997-2014, International Business Machines Corporation and | |
| 4 * others. All Rights Reserved. | |
| 5 ********************************************************************/ | |
| 6 /******************************************************************************* | |
| 7 * | |
| 8 * File CALLCOLL.C | |
| 9 * | |
| 10 * Modification History: | |
| 11 * Name Description | |
| 12 * Madhu Katragadda Ported for C API | |
| 13 ******************************************************************************** | |
| 14 */ | |
| 15 | |
| 16 /* | |
| 17 * Important: This file is included into intltest/allcoll.cpp so that the | |
| 18 * test data is shared. This makes it easier to maintain the test data, | |
| 19 * especially since the Unicode data must be portable and quoted character | |
| 20 * literals will not work. | |
| 21 * If it is included, then there will be a #define INCLUDE_CALLCOLL_C | |
| 22 * that must prevent the actual code in here from being part of the | |
| 23 * allcoll.cpp compilation. | |
| 24 */ | |
| 25 | |
| 26 /** | |
| 27 * CollationDummyTest is a third level test class. This tests creation of | |
| 28 * a customized collator object. For example, number 1 to be sorted | |
| 29 * equlivalent to word 'one'. | |
| 30 */ | |
| 31 | |
| 32 #include <string.h> | |
| 33 #include <stdlib.h> | |
| 34 | |
| 35 #include "unicode/utypes.h" | |
| 36 | |
| 37 #if !UCONFIG_NO_COLLATION | |
| 38 | |
| 39 #include "unicode/ucol.h" | |
| 40 #include "unicode/uloc.h" | |
| 41 #include "unicode/ures.h" | |
| 42 #include "unicode/udata.h" | |
| 43 #include "unicode/ucoleitr.h" | |
| 44 #include "unicode/ustring.h" | |
| 45 #include "unicode/uclean.h" | |
| 46 #include "unicode/putil.h" | |
| 47 #include "unicode/uenum.h" | |
| 48 | |
| 49 #include "cintltst.h" | |
| 50 #include "ccolltst.h" | |
| 51 #include "callcoll.h" | |
| 52 #include "calldata.h" | |
| 53 #include "cstring.h" | |
| 54 #include "cmemory.h" | |
| 55 | |
| 56 /* set to 1 to test offsets in backAndForth() */ | |
| 57 #define TEST_OFFSETS 0 | |
| 58 | |
| 59 /* perform test with strength PRIMARY */ | |
| 60 static void TestPrimary(void); | |
| 61 | |
| 62 /* perform test with strength SECONDARY */ | |
| 63 static void TestSecondary(void); | |
| 64 | |
| 65 /* perform test with strength tertiary */ | |
| 66 static void TestTertiary(void); | |
| 67 | |
| 68 /*perform tests with strength Identical */ | |
| 69 static void TestIdentical(void); | |
| 70 | |
| 71 /* perform extra tests */ | |
| 72 static void TestExtra(void); | |
| 73 | |
| 74 /* Test jitterbug 581 */ | |
| 75 static void TestJB581(void); | |
| 76 | |
| 77 /* Test jitterbug 1401 */ | |
| 78 static void TestJB1401(void); | |
| 79 | |
| 80 /* Test [variable top] in the rule syntax */ | |
| 81 static void TestVariableTop(void); | |
| 82 | |
| 83 /* Test surrogates */ | |
| 84 static void TestSurrogates(void); | |
| 85 | |
| 86 static void TestInvalidRules(void); | |
| 87 | |
| 88 static void TestJitterbug1098(void); | |
| 89 | |
| 90 static void TestFCDCrash(void); | |
| 91 | |
| 92 static void TestJ5298(void); | |
| 93 | |
| 94 const UCollationResult results[] = { | |
| 95 UCOL_LESS, | |
| 96 UCOL_LESS, /*UCOL_GREATER,*/ | |
| 97 UCOL_LESS, | |
| 98 UCOL_LESS, | |
| 99 UCOL_LESS, | |
| 100 UCOL_LESS, | |
| 101 UCOL_LESS, | |
| 102 UCOL_GREATER, | |
| 103 UCOL_GREATER, | |
| 104 UCOL_LESS, /* 10 */ | |
| 105 UCOL_GREATER, | |
| 106 UCOL_LESS, | |
| 107 UCOL_GREATER, | |
| 108 UCOL_GREATER, | |
| 109 UCOL_LESS, | |
| 110 UCOL_LESS, | |
| 111 UCOL_LESS, | |
| 112 /* test primary > 17 */ | |
| 113 UCOL_EQUAL, | |
| 114 UCOL_EQUAL, | |
| 115 UCOL_EQUAL, /* 20 */ | |
| 116 UCOL_LESS, | |
| 117 UCOL_LESS, | |
| 118 UCOL_EQUAL, | |
| 119 UCOL_EQUAL, | |
| 120 UCOL_EQUAL, | |
| 121 UCOL_LESS, | |
| 122 /* test secondary > 26 */ | |
| 123 UCOL_EQUAL, | |
| 124 UCOL_EQUAL, | |
| 125 UCOL_EQUAL, | |
| 126 UCOL_EQUAL, | |
| 127 UCOL_EQUAL, /* 30 */ | |
| 128 UCOL_EQUAL, | |
| 129 UCOL_LESS, | |
| 130 UCOL_EQUAL, /* 34 */ | |
| 131 UCOL_EQUAL, | |
| 132 UCOL_EQUAL, | |
| 133 UCOL_LESS /* 37 */ | |
| 134 }; | |
| 135 | |
| 136 | |
| 137 static | |
| 138 void uprv_appendByteToHexString(char *dst, uint8_t val) { | |
| 139 uint32_t len = (uint32_t)uprv_strlen(dst); | |
| 140 *(dst+len) = T_CString_itosOffset((val >> 4)); | |
| 141 *(dst+len+1) = T_CString_itosOffset((val & 0xF)); | |
| 142 *(dst+len+2) = 0; | |
| 143 } | |
| 144 | |
| 145 /* this function makes a string with representation of a sortkey */ | |
| 146 static char* U_EXPORT2 sortKeyToString(const UCollator *coll, const uint8_t *sor
tkey, char *buffer, uint32_t *len) { | |
| 147 int32_t strength = UCOL_PRIMARY; | |
| 148 uint32_t res_size = 0; | |
| 149 UBool doneCase = FALSE; | |
| 150 UErrorCode errorCode = U_ZERO_ERROR; | |
| 151 | |
| 152 char *current = buffer; | |
| 153 const uint8_t *currentSk = sortkey; | |
| 154 | |
| 155 uprv_strcpy(current, "["); | |
| 156 | |
| 157 while(strength <= UCOL_QUATERNARY && strength <= ucol_getStrength(coll)) { | |
| 158 if(strength > UCOL_PRIMARY) { | |
| 159 uprv_strcat(current, " . "); | |
| 160 } | |
| 161 while(*currentSk != 0x01 && *currentSk != 0x00) { /* print a level */ | |
| 162 uprv_appendByteToHexString(current, *currentSk++); | |
| 163 uprv_strcat(current, " "); | |
| 164 } | |
| 165 if(ucol_getAttribute(coll, UCOL_CASE_LEVEL, &errorCode) == UCOL_ON && st
rength == UCOL_SECONDARY && doneCase == FALSE) { | |
| 166 doneCase = TRUE; | |
| 167 } else if(ucol_getAttribute(coll, UCOL_CASE_LEVEL, &errorCode) == UCOL_O
FF || doneCase == TRUE || strength != UCOL_SECONDARY) { | |
| 168 strength ++; | |
| 169 } | |
| 170 if (*currentSk) { | |
| 171 uprv_appendByteToHexString(current, *currentSk++); /* This should pr
int '01' */ | |
| 172 } | |
| 173 if(strength == UCOL_QUATERNARY && ucol_getAttribute(coll, UCOL_ALTERNATE
_HANDLING, &errorCode) == UCOL_NON_IGNORABLE) { | |
| 174 break; | |
| 175 } | |
| 176 } | |
| 177 | |
| 178 if(ucol_getStrength(coll) == UCOL_IDENTICAL) { | |
| 179 uprv_strcat(current, " . "); | |
| 180 while(*currentSk != 0) { | |
| 181 uprv_appendByteToHexString(current, *currentSk++); | |
| 182 uprv_strcat(current, " "); | |
| 183 } | |
| 184 | |
| 185 uprv_appendByteToHexString(current, *currentSk++); | |
| 186 } | |
| 187 uprv_strcat(current, "]"); | |
| 188 | |
| 189 if(res_size > *len) { | |
| 190 return NULL; | |
| 191 } | |
| 192 | |
| 193 return buffer; | |
| 194 } | |
| 195 | |
| 196 void addAllCollTest(TestNode** root) | |
| 197 { | |
| 198 addTest(root, &TestPrimary, "tscoll/callcoll/TestPrimary"); | |
| 199 addTest(root, &TestSecondary, "tscoll/callcoll/TestSecondary"); | |
| 200 addTest(root, &TestTertiary, "tscoll/callcoll/TestTertiary"); | |
| 201 addTest(root, &TestIdentical, "tscoll/callcoll/TestIdentical"); | |
| 202 addTest(root, &TestExtra, "tscoll/callcoll/TestExtra"); | |
| 203 addTest(root, &TestJB581, "tscoll/callcoll/TestJB581"); | |
| 204 addTest(root, &TestVariableTop, "tscoll/callcoll/TestVariableTop"); | |
| 205 addTest(root, &TestSurrogates, "tscoll/callcoll/TestSurrogates"); | |
| 206 addTest(root, &TestInvalidRules, "tscoll/callcoll/TestInvalidRules"); | |
| 207 addTest(root, &TestJB1401, "tscoll/callcoll/TestJB1401"); | |
| 208 addTest(root, &TestJitterbug1098, "tscoll/callcoll/TestJitterbug1098"); | |
| 209 addTest(root, &TestFCDCrash, "tscoll/callcoll/TestFCDCrash"); | |
| 210 addTest(root, &TestJ5298, "tscoll/callcoll/TestJ5298"); | |
| 211 } | |
| 212 | |
| 213 UBool hasCollationElements(const char *locName) { | |
| 214 | |
| 215 UErrorCode status = U_ZERO_ERROR; | |
| 216 | |
| 217 UResourceBundle *loc = ures_open(U_ICUDATA_NAME U_TREE_SEPARATOR_STRING "coll"
, locName, &status);; | |
| 218 | |
| 219 if(U_SUCCESS(status)) { | |
| 220 status = U_ZERO_ERROR; | |
| 221 loc = ures_getByKey(loc, "collations", loc, &status); | |
| 222 ures_close(loc); | |
| 223 if(status == U_ZERO_ERROR) { /* do the test - there are real elements */ | |
| 224 return TRUE; | |
| 225 } | |
| 226 } | |
| 227 return FALSE; | |
| 228 } | |
| 229 | |
| 230 static UCollationResult compareUsingPartials(UCollator *coll, const UChar source
[], int32_t sLen, const UChar target[], int32_t tLen, int32_t pieceSize, UErrorC
ode *status) { | |
| 231 int32_t partialSKResult = 0; | |
| 232 UCharIterator sIter, tIter; | |
| 233 uint32_t sState[2], tState[2]; | |
| 234 int32_t sSize = pieceSize, tSize = pieceSize; | |
| 235 /*int32_t i = 0;*/ | |
| 236 uint8_t sBuf[16384], tBuf[16384]; | |
| 237 if(pieceSize > 16384) { | |
| 238 log_err("Partial sortkey size buffer too small. Please consider increasing t
he buffer!\n"); | |
| 239 *status = U_BUFFER_OVERFLOW_ERROR; | |
| 240 return UCOL_EQUAL; | |
| 241 } | |
| 242 *status = U_ZERO_ERROR; | |
| 243 sState[0] = 0; sState[1] = 0; | |
| 244 tState[0] = 0; tState[1] = 0; | |
| 245 while(sSize == pieceSize && tSize == pieceSize && partialSKResult == 0) { | |
| 246 uiter_setString(&sIter, source, sLen); | |
| 247 uiter_setString(&tIter, target, tLen); | |
| 248 sSize = ucol_nextSortKeyPart(coll, &sIter, sState, sBuf, pieceSize, status); | |
| 249 tSize = ucol_nextSortKeyPart(coll, &tIter, tState, tBuf, pieceSize, status); | |
| 250 | |
| 251 if(sState[0] != 0 || tState[0] != 0) { | |
| 252 /*log_verbose("State != 0 : %08X %08X\n", sState[0], tState[0]);*/ | |
| 253 } | |
| 254 /*log_verbose("%i ", i++);*/ | |
| 255 | |
| 256 partialSKResult = memcmp(sBuf, tBuf, pieceSize); | |
| 257 } | |
| 258 | |
| 259 if(partialSKResult < 0) { | |
| 260 return UCOL_LESS; | |
| 261 } else if(partialSKResult > 0) { | |
| 262 return UCOL_GREATER; | |
| 263 } else { | |
| 264 return UCOL_EQUAL; | |
| 265 } | |
| 266 } | |
| 267 | |
| 268 static void doTestVariant(UCollator* myCollation, const UChar source[], const UC
har target[], UCollationResult result) | |
| 269 { | |
| 270 int32_t sortklen1, sortklen2, sortklenmax, sortklenmin; | |
| 271 int temp=0, gSortklen1=0,gSortklen2=0; | |
| 272 UCollationResult compareResult, compareResulta, keyResult, compareResultIter
= result; | |
| 273 uint8_t *sortKey1, *sortKey2, *sortKey1a, *sortKey2a; | |
| 274 uint32_t sLen = u_strlen(source); | |
| 275 uint32_t tLen = u_strlen(target); | |
| 276 char buffer[256]; | |
| 277 uint32_t len; | |
| 278 UErrorCode status = U_ZERO_ERROR; | |
| 279 UColAttributeValue norm = ucol_getAttribute(myCollation, UCOL_NORMALIZATION_
MODE, &status); | |
| 280 | |
| 281 UCharIterator sIter, tIter; | |
| 282 | |
| 283 compareResult = ucol_strcoll(myCollation, source, sLen, target, tLen); | |
| 284 if (compareResult != result) { | |
| 285 log_err("ucol_strcoll with explicit length returned wrong result (%i exp
. %i): %s, %s\n", | |
| 286 compareResult, result, aescstrdup(source,-1), aescstrdup(target,-1))
; | |
| 287 } | |
| 288 compareResulta = ucol_strcoll(myCollation, source, -1, target, -1); | |
| 289 if (compareResulta != result) { | |
| 290 log_err("ucol_strcoll with null terminated strings returned wrong result
(%i exp. %i): %s, %s\n", | |
| 291 compareResult, result, aescstrdup(source,-1), aescstrdup(target,-1))
; | |
| 292 } | |
| 293 | |
| 294 uiter_setString(&sIter, source, sLen); | |
| 295 uiter_setString(&tIter, target, tLen); | |
| 296 compareResultIter = ucol_strcollIter(myCollation, &sIter, &tIter, &status); | |
| 297 if(compareResultIter != result) { | |
| 298 log_err("different results in iterative comparison for UTF-16 encoded st
rings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1)); | |
| 299 } | |
| 300 | |
| 301 /* convert the strings to UTF-8 and do try comparing with char iterator and
ucol_strcollUTF8 */ | |
| 302 { | |
| 303 char utf8Source[256], utf8Target[256]; | |
| 304 int32_t utf8SourceLen = 0, utf8TargetLen = 0; | |
| 305 | |
| 306 u_strToUTF8(utf8Source, 256, &utf8SourceLen, source, sLen, &status); | |
| 307 if(U_FAILURE(status)) { /* probably buffer is not big enough */ | |
| 308 log_verbose("Src UTF-8 buffer too small! Will not compare!\n"); | |
| 309 } else { | |
| 310 u_strToUTF8(utf8Target, 256, &utf8TargetLen, target, tLen, &status); | |
| 311 if(U_SUCCESS(status)) { | |
| 312 { | |
| 313 /* ucol_strcollUTF8 */ | |
| 314 compareResulta = ucol_strcollUTF8(myCollation, utf8Source, u
tf8SourceLen, utf8Target, utf8TargetLen, &status); | |
| 315 if (U_FAILURE(status)) { | |
| 316 log_err("Error in ucol_strcollUTF8 with explicit length\
n"); | |
| 317 status = U_ZERO_ERROR; | |
| 318 } else if (compareResulta != result) { | |
| 319 log_err("ucol_strcollUTF8 with explicit length returned
wrong result (%i exp. %i): %s, %s\n", | |
| 320 compareResulta, result, aescstrdup(source,-1), aescs
trdup(target,-1)); | |
| 321 } | |
| 322 compareResulta = ucol_strcollUTF8(myCollation, utf8Source, -
1, utf8Target, -1, &status); | |
| 323 if (U_FAILURE(status)) { | |
| 324 log_err("Error in ucol_strcollUTF8 with null terminated
strings\n"); | |
| 325 status = U_ZERO_ERROR; | |
| 326 } else if (compareResulta != result) { | |
| 327 log_err("ucol_strcollUTF8 with null terminated strings r
eturned wrong result (%i exp. %i): %s, %s\n", | |
| 328 compareResulta, result, aescstrdup(source,-1), aescs
trdup(target,-1)); | |
| 329 } | |
| 330 } | |
| 331 | |
| 332 { | |
| 333 /* char iterator over UTF8 */ | |
| 334 UCollationResult compareResultUTF8Iter = result, compareResu
ltUTF8IterNorm = result; | |
| 335 | |
| 336 uiter_setUTF8(&sIter, utf8Source, utf8SourceLen); | |
| 337 uiter_setUTF8(&tIter, utf8Target, utf8TargetLen); | |
| 338 compareResultUTF8Iter = ucol_strcollIter(myCollation, &sIter
, &tIter, &status); | |
| 339 | |
| 340 ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, UCOL
_ON, &status); | |
| 341 sIter.move(&sIter, 0, UITER_START); | |
| 342 tIter.move(&tIter, 0, UITER_START); | |
| 343 compareResultUTF8IterNorm = ucol_strcollIter(myCollation, &s
Iter, &tIter, &status); | |
| 344 | |
| 345 ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, norm
, &status); | |
| 346 if(compareResultUTF8Iter != compareResultIter) { | |
| 347 log_err("different results in iterative comparison for U
TF-16 and UTF-8 encoded strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(ta
rget,-1)); | |
| 348 } | |
| 349 if(compareResultUTF8Iter != compareResultUTF8IterNorm) { | |
| 350 log_err("different results in iterative when normalizati
on is turned on with UTF-8 strings. %s, %s\n", aescstrdup(source,-1), aescstrdup
(target,-1)); | |
| 351 } | |
| 352 } | |
| 353 } else { | |
| 354 log_verbose("Target UTF-8 buffer too small! Did not compare!\n")
; | |
| 355 } | |
| 356 if(U_FAILURE(status)) { | |
| 357 log_verbose("UTF-8 strcoll failed! Ignoring result\n"); | |
| 358 } | |
| 359 } | |
| 360 } | |
| 361 | |
| 362 /* testing the partial sortkeys */ | |
| 363 if(1) { /*!QUICK*/ | |
| 364 int32_t i = 0; | |
| 365 int32_t partialSizes[] = { 3, 1, 2, 4, 8, 20, 80 }; /* just size 3 in the
quick mode */ | |
| 366 int32_t partialSizesSize = 1; | |
| 367 if(getTestOption(QUICK_OPTION) <= 0) { | |
| 368 partialSizesSize = 7; | |
| 369 } | |
| 370 /*log_verbose("partial sortkey test piecesize=");*/ | |
| 371 for(i = 0; i < partialSizesSize; i++) { | |
| 372 UCollationResult partialSKResult = result, partialNormalizedSKResult = r
esult; | |
| 373 /*log_verbose("%i ", partialSizes[i]);*/ | |
| 374 | |
| 375 partialSKResult = compareUsingPartials(myCollation, source, sLen, target
, tLen, partialSizes[i], &status); | |
| 376 if(partialSKResult != result) { | |
| 377 log_err("Partial sortkey comparison returned wrong result (%i exp. %i)
: %s, %s (size %i)\n", | |
| 378 partialSKResult, result, | |
| 379 aescstrdup(source,-1), aescstrdup(target,-1), partialSizes[i]); | |
| 380 } | |
| 381 | |
| 382 if(getTestOption(QUICK_OPTION) <= 0 && norm != UCOL_ON) { | |
| 383 /*log_verbose("N ");*/ | |
| 384 ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, UCOL_ON, &stat
us); | |
| 385 partialNormalizedSKResult = compareUsingPartials(myCollation, source,
sLen, target, tLen, partialSizes[i], &status); | |
| 386 ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, norm, &status)
; | |
| 387 if(partialSKResult != partialNormalizedSKResult) { | |
| 388 log_err("Partial sortkey comparison gets different result when norma
lization is on: %s, %s (size %i)\n", | |
| 389 aescstrdup(source,-1), aescstrdup(target,-1), partialSizes[i]); | |
| 390 } | |
| 391 } | |
| 392 } | |
| 393 /*log_verbose("\n");*/ | |
| 394 } | |
| 395 | |
| 396 sortklen1=ucol_getSortKey(myCollation, source, sLen, NULL, 0); | |
| 397 sortklen2=ucol_getSortKey(myCollation, target, tLen, NULL, 0); | |
| 398 | |
| 399 sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2); | |
| 400 sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2); | |
| 401 (void)sortklenmin; /* Suppress set but not used warning. */ | |
| 402 | |
| 403 sortKey1 =(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1)); | |
| 404 sortKey1a=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1)); | |
| 405 ucol_getSortKey(myCollation, source, sLen, sortKey1, sortklen1+1); | |
| 406 ucol_getSortKey(myCollation, source, -1, sortKey1a, sortklen1+1); | |
| 407 | |
| 408 sortKey2 =(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1)); | |
| 409 sortKey2a=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1)); | |
| 410 ucol_getSortKey(myCollation, target, tLen, sortKey2, sortklen2+1); | |
| 411 ucol_getSortKey(myCollation, target, -1, sortKey2a, sortklen2+1); | |
| 412 | |
| 413 /* Check that sort key generated with null terminated string is identical *
/ | |
| 414 /* to that generted with a length specified. *
/ | |
| 415 if (uprv_strcmp((const char *)sortKey1, (const char *)sortKey1a) != 0 || | |
| 416 uprv_strcmp((const char *)sortKey2, (const char *)sortKey2a) != 0 ) { | |
| 417 log_err("Sort Keys from null terminated and explicit length strings diff
er.\n"); | |
| 418 } | |
| 419 | |
| 420 /*memcmp(sortKey1, sortKey2,sortklenmax);*/ | |
| 421 temp= uprv_strcmp((const char *)sortKey1, (const char *)sortKey2); | |
| 422 gSortklen1 = uprv_strlen((const char *)sortKey1)+1; | |
| 423 gSortklen2 = uprv_strlen((const char *)sortKey2)+1; | |
| 424 if(sortklen1 != gSortklen1){ | |
| 425 log_err("SortKey length does not match Expected: %i Got: %i\n",sortklen1
, gSortklen1); | |
| 426 log_verbose("Generated sortkey: %s\n", sortKeyToString(myCollation, sort
Key1, buffer, &len)); | |
| 427 } | |
| 428 if(sortklen2!= gSortklen2){ | |
| 429 log_err("SortKey length does not match Expected: %i Got: %i\n", sortklen
2, gSortklen2); | |
| 430 log_verbose("Generated sortkey: %s\n", sortKeyToString(myCollation, sort
Key2, buffer, &len)); | |
| 431 } | |
| 432 | |
| 433 if(temp < 0) { | |
| 434 keyResult=UCOL_LESS; | |
| 435 } | |
| 436 else if(temp > 0) { | |
| 437 keyResult= UCOL_GREATER; | |
| 438 } | |
| 439 else { | |
| 440 keyResult = UCOL_EQUAL; | |
| 441 } | |
| 442 reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult,
compareResultIter, result ); | |
| 443 free(sortKey1); | |
| 444 free(sortKey2); | |
| 445 free(sortKey1a); | |
| 446 free(sortKey2a); | |
| 447 | |
| 448 } | |
| 449 | |
| 450 void doTest(UCollator* myCollation, const UChar source[], const UChar target[],
UCollationResult result) | |
| 451 { | |
| 452 if(myCollation) { | |
| 453 doTestVariant(myCollation, source, target, result); | |
| 454 if(result == UCOL_LESS) { | |
| 455 doTestVariant(myCollation, target, source, UCOL_GREATER); | |
| 456 } else if(result == UCOL_GREATER) { | |
| 457 doTestVariant(myCollation, target, source, UCOL_LESS); | |
| 458 } else { | |
| 459 doTestVariant(myCollation, target, source, UCOL_EQUAL); | |
| 460 } | |
| 461 } else { | |
| 462 log_data_err("No collator! Any data around?\n"); | |
| 463 } | |
| 464 } | |
| 465 | |
| 466 | |
| 467 /** | |
| 468 * Return an integer array containing all of the collation orders | |
| 469 * returned by calls to next on the specified iterator | |
| 470 */ | |
| 471 OrderAndOffset* getOrders(UCollationElements *iter, int32_t *orderLength) | |
| 472 { | |
| 473 UErrorCode status; | |
| 474 int32_t order; | |
| 475 int32_t maxSize = 100; | |
| 476 int32_t size = 0; | |
| 477 int32_t offset = ucol_getOffset(iter); | |
| 478 OrderAndOffset *temp; | |
| 479 OrderAndOffset *orders =(OrderAndOffset *)malloc(sizeof(OrderAndOffset) * ma
xSize); | |
| 480 status= U_ZERO_ERROR; | |
| 481 | |
| 482 | |
| 483 while ((order=ucol_next(iter, &status)) != UCOL_NULLORDER) | |
| 484 { | |
| 485 if (size == maxSize) | |
| 486 { | |
| 487 maxSize *= 2; | |
| 488 temp = (OrderAndOffset *)malloc(sizeof(OrderAndOffset) * maxSize); | |
| 489 | |
| 490 memcpy(temp, orders, size * sizeof(OrderAndOffset)); | |
| 491 free(orders); | |
| 492 orders = temp; | |
| 493 | |
| 494 } | |
| 495 | |
| 496 orders[size].order = order; | |
| 497 orders[size].offset = offset; | |
| 498 | |
| 499 offset = ucol_getOffset(iter); | |
| 500 size += 1; | |
| 501 } | |
| 502 | |
| 503 if (maxSize > size && size > 0) | |
| 504 { | |
| 505 temp = (OrderAndOffset *)malloc(sizeof(OrderAndOffset) * size); | |
| 506 | |
| 507 memcpy(temp, orders, size * sizeof(OrderAndOffset)); | |
| 508 free(orders); | |
| 509 orders = temp; | |
| 510 | |
| 511 | |
| 512 } | |
| 513 | |
| 514 *orderLength = size; | |
| 515 return orders; | |
| 516 } | |
| 517 | |
| 518 | |
| 519 void | |
| 520 backAndForth(UCollationElements *iter) | |
| 521 { | |
| 522 /* Run through the iterator forwards and stick it into an array */ | |
| 523 int32_t idx, o; | |
| 524 UErrorCode status = U_ZERO_ERROR; | |
| 525 int32_t orderLength = 0; | |
| 526 OrderAndOffset *orders = getOrders(iter, &orderLength); | |
| 527 | |
| 528 | |
| 529 /* Now go through it backwards and make sure we get the same values */ | |
| 530 idx = orderLength; | |
| 531 ucol_reset(iter); | |
| 532 | |
| 533 /* synwee : changed */ | |
| 534 while ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER) { | |
| 535 #if TEST_OFFSETS | |
| 536 int32_t offset = | |
| 537 #endif | |
| 538 ucol_getOffset(iter); | |
| 539 | |
| 540 idx -= 1; | |
| 541 if (o != orders[idx].order) { | |
| 542 if (o == 0) | |
| 543 idx ++; | |
| 544 else { | |
| 545 while (idx > 0 && orders[-- idx].order == 0) { | |
| 546 /* nothing... */ | |
| 547 } | |
| 548 | |
| 549 if (o != orders[idx].order) { | |
| 550 log_err("Mismatched order at index %d: 0x%8.8X vs. 0x%8.8X\n", idx
, | |
| 551 orders[idx].order, o); | |
| 552 goto bail; | |
| 553 } | |
| 554 } | |
| 555 } | |
| 556 | |
| 557 #if TEST_OFFSETS | |
| 558 if (offset != orders[idx].offset) { | |
| 559 log_err("Mismatched offset at index %d: %d vs. %d\n", idx, | |
| 560 orders[idx].offset, offset); | |
| 561 goto bail; | |
| 562 } | |
| 563 #endif | |
| 564 | |
| 565 } | |
| 566 | |
| 567 while (idx != 0 && orders[idx - 1].order == 0) { | |
| 568 idx -= 1; | |
| 569 } | |
| 570 | |
| 571 if (idx != 0) { | |
| 572 log_err("Didn't get back to beginning - index is %d\n", idx); | |
| 573 | |
| 574 ucol_reset(iter); | |
| 575 log_err("\nnext: "); | |
| 576 | |
| 577 if ((o = ucol_next(iter, &status)) != UCOL_NULLORDER) { | |
| 578 log_err("Error at %x\n", o); | |
| 579 } | |
| 580 | |
| 581 log_err("\nprev: "); | |
| 582 | |
| 583 if ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER) { | |
| 584 log_err("Error at %x\n", o); | |
| 585 } | |
| 586 | |
| 587 log_verbose("\n"); | |
| 588 } | |
| 589 | |
| 590 bail: | |
| 591 free(orders); | |
| 592 } | |
| 593 | |
| 594 void genericOrderingTestWithResult(UCollator *coll, const char * const s[], uint
32_t size, UCollationResult result) { | |
| 595 UChar t1[2048] = {0}; | |
| 596 UChar t2[2048] = {0}; | |
| 597 UCollationElements *iter; | |
| 598 UErrorCode status = U_ZERO_ERROR; | |
| 599 | |
| 600 uint32_t i = 0, j = 0; | |
| 601 log_verbose("testing sequence:\n"); | |
| 602 for(i = 0; i < size; i++) { | |
| 603 log_verbose("%s\n", s[i]); | |
| 604 } | |
| 605 | |
| 606 iter = ucol_openElements(coll, t1, u_strlen(t1), &status); | |
| 607 if (U_FAILURE(status)) { | |
| 608 log_err("Creation of iterator failed\n"); | |
| 609 } | |
| 610 for(i = 0; i < size-1; i++) { | |
| 611 for(j = i+1; j < size; j++) { | |
| 612 u_unescape(s[i], t1, 2048); | |
| 613 u_unescape(s[j], t2, 2048); | |
| 614 doTest(coll, t1, t2, result); | |
| 615 /* synwee : added collation element iterator test */ | |
| 616 ucol_setText(iter, t1, u_strlen(t1), &status); | |
| 617 backAndForth(iter); | |
| 618 ucol_setText(iter, t2, u_strlen(t2), &status); | |
| 619 backAndForth(iter); | |
| 620 } | |
| 621 } | |
| 622 ucol_closeElements(iter); | |
| 623 } | |
| 624 | |
| 625 void genericOrderingTest(UCollator *coll, const char * const s[], uint32_t size)
{ | |
| 626 genericOrderingTestWithResult(coll, s, size, UCOL_LESS); | |
| 627 } | |
| 628 | |
| 629 void genericLocaleStarter(const char *locale, const char * const s[], uint32_t s
ize) { | |
| 630 UErrorCode status = U_ZERO_ERROR; | |
| 631 UCollator *coll = ucol_open(locale, &status); | |
| 632 | |
| 633 log_verbose("Locale starter for %s\n", locale); | |
| 634 | |
| 635 if(U_SUCCESS(status)) { | |
| 636 genericOrderingTest(coll, s, size); | |
| 637 } else if(status == U_FILE_ACCESS_ERROR) { | |
| 638 log_data_err("Is your data around?\n"); | |
| 639 return; | |
| 640 } else { | |
| 641 log_err("Unable to open collator for locale %s\n", locale); | |
| 642 } | |
| 643 ucol_close(coll); | |
| 644 } | |
| 645 | |
| 646 void genericLocaleStarterWithResult(const char *locale, const char * const s[],
uint32_t size, UCollationResult result) { | |
| 647 UErrorCode status = U_ZERO_ERROR; | |
| 648 UCollator *coll = ucol_open(locale, &status); | |
| 649 | |
| 650 log_verbose("Locale starter for %s\n", locale); | |
| 651 | |
| 652 if(U_SUCCESS(status)) { | |
| 653 genericOrderingTestWithResult(coll, s, size, result); | |
| 654 } else if(status == U_FILE_ACCESS_ERROR) { | |
| 655 log_data_err("Is your data around?\n"); | |
| 656 return; | |
| 657 } else { | |
| 658 log_err("Unable to open collator for locale %s\n", locale); | |
| 659 } | |
| 660 ucol_close(coll); | |
| 661 } | |
| 662 | |
| 663 /* currently not used with options */ | |
| 664 void genericRulesStarterWithOptionsAndResult(const char *rules, const char * con
st s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *val
ues, uint32_t attsize, UCollationResult result) { | |
| 665 UErrorCode status = U_ZERO_ERROR; | |
| 666 UChar rlz[RULE_BUFFER_LEN] = { 0 }; | |
| 667 uint32_t rlen = u_unescape(rules, rlz, RULE_BUFFER_LEN); | |
| 668 uint32_t i; | |
| 669 | |
| 670 UCollator *coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &
status); | |
| 671 | |
| 672 log_verbose("Rules starter for %s\n", rules); | |
| 673 | |
| 674 if(U_SUCCESS(status)) { | |
| 675 log_verbose("Setting attributes\n"); | |
| 676 for(i = 0; i < attsize; i++) { | |
| 677 ucol_setAttribute(coll, attrs[i], values[i], &status); | |
| 678 } | |
| 679 | |
| 680 genericOrderingTestWithResult(coll, s, size, result); | |
| 681 } else { | |
| 682 log_err_status(status, "Unable to open collator with rules %s\n", rules); | |
| 683 } | |
| 684 ucol_close(coll); | |
| 685 } | |
| 686 | |
| 687 void genericLocaleStarterWithOptionsAndResult(const char *locale, const char * c
onst s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *v
alues, uint32_t attsize, UCollationResult result) { | |
| 688 UErrorCode status = U_ZERO_ERROR; | |
| 689 uint32_t i; | |
| 690 | |
| 691 UCollator *coll = ucol_open(locale, &status); | |
| 692 | |
| 693 log_verbose("Locale starter for %s\n", locale); | |
| 694 | |
| 695 if(U_SUCCESS(status)) { | |
| 696 | |
| 697 log_verbose("Setting attributes\n"); | |
| 698 for(i = 0; i < attsize; i++) { | |
| 699 ucol_setAttribute(coll, attrs[i], values[i], &status); | |
| 700 } | |
| 701 | |
| 702 genericOrderingTestWithResult(coll, s, size, result); | |
| 703 } else { | |
| 704 log_err_status(status, "Unable to open collator for locale %s\n", locale); | |
| 705 } | |
| 706 ucol_close(coll); | |
| 707 } | |
| 708 | |
| 709 void genericLocaleStarterWithOptions(const char *locale, const char * const s[],
uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, ui
nt32_t attsize) { | |
| 710 genericLocaleStarterWithOptionsAndResult(locale, s, size, attrs, values, attsi
ze, UCOL_LESS); | |
| 711 } | |
| 712 | |
| 713 void genericRulesStarterWithResult(const char *rules, const char * const s[], ui
nt32_t size, UCollationResult result) { | |
| 714 UErrorCode status = U_ZERO_ERROR; | |
| 715 UChar rlz[RULE_BUFFER_LEN] = { 0 }; | |
| 716 uint32_t rlen = u_unescape(rules, rlz, RULE_BUFFER_LEN); | |
| 717 | |
| 718 UCollator *coll = NULL; | |
| 719 coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &status); | |
| 720 log_verbose("Rules starter for %s\n", rules); | |
| 721 | |
| 722 if(U_SUCCESS(status)) { | |
| 723 genericOrderingTestWithResult(coll, s, size, result); | |
| 724 ucol_close(coll); | |
| 725 } else if(status == U_FILE_ACCESS_ERROR) { | |
| 726 log_data_err("Is your data around?\n"); | |
| 727 } else { | |
| 728 log_err("Unable to open collator with rules %s\n", rules); | |
| 729 } | |
| 730 } | |
| 731 | |
| 732 void genericRulesStarter(const char *rules, const char * const s[], uint32_t siz
e) { | |
| 733 genericRulesStarterWithResult(rules, s, size, UCOL_LESS); | |
| 734 } | |
| 735 | |
| 736 static void TestTertiary() | |
| 737 { | |
| 738 int32_t len,i; | |
| 739 UCollator *myCollation; | |
| 740 UErrorCode status=U_ZERO_ERROR; | |
| 741 static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 &
Ampersand; '&' & Two, 2 "; | |
| 742 UChar rules[sizeof(str)]; | |
| 743 len = strlen(str); | |
| 744 u_uastrcpy(rules, str); | |
| 745 | |
| 746 myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH, NULL
, &status); | |
| 747 if(U_FAILURE(status)){ | |
| 748 log_err_status(status, "ERROR: in creation of rule based collator :%s\n"
, myErrorName(status)); | |
| 749 return; | |
| 750 } | |
| 751 | |
| 752 ucol_setStrength(myCollation, UCOL_TERTIARY); | |
| 753 for (i = 0; i < 17 ; i++) | |
| 754 { | |
| 755 doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]); | |
| 756 } | |
| 757 ucol_close(myCollation); | |
| 758 myCollation = 0; | |
| 759 } | |
| 760 | |
| 761 static void TestPrimary( ) | |
| 762 { | |
| 763 int32_t len,i; | |
| 764 UCollator *myCollation; | |
| 765 UErrorCode status=U_ZERO_ERROR; | |
| 766 static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 &
Ampersand; '&' & Two, 2 "; | |
| 767 UChar rules[sizeof(str)]; | |
| 768 len = strlen(str); | |
| 769 u_uastrcpy(rules, str); | |
| 770 | |
| 771 myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL,
&status); | |
| 772 if(U_FAILURE(status)){ | |
| 773 log_err_status(status, "ERROR: in creation of rule based collator :%s\n"
, myErrorName(status)); | |
| 774 return; | |
| 775 } | |
| 776 ucol_setStrength(myCollation, UCOL_PRIMARY); | |
| 777 | |
| 778 for (i = 17; i < 26 ; i++) | |
| 779 { | |
| 780 | |
| 781 doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]); | |
| 782 } | |
| 783 ucol_close(myCollation); | |
| 784 myCollation = 0; | |
| 785 } | |
| 786 | |
| 787 static void TestSecondary() | |
| 788 { | |
| 789 int32_t i; | |
| 790 int32_t len; | |
| 791 UCollator *myCollation; | |
| 792 UErrorCode status=U_ZERO_ERROR; | |
| 793 static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 &
Ampersand; '&' & Two, 2 "; | |
| 794 UChar rules[sizeof(str)]; | |
| 795 len = strlen(str); | |
| 796 u_uastrcpy(rules, str); | |
| 797 | |
| 798 myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL,
&status); | |
| 799 if(U_FAILURE(status)){ | |
| 800 log_err_status(status, "ERROR: in creation of rule based collator :%s\n"
, myErrorName(status)); | |
| 801 return; | |
| 802 } | |
| 803 ucol_setStrength(myCollation, UCOL_SECONDARY); | |
| 804 for (i = 26; i < 34 ; i++) | |
| 805 { | |
| 806 doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]); | |
| 807 } | |
| 808 ucol_close(myCollation); | |
| 809 myCollation = 0; | |
| 810 } | |
| 811 | |
| 812 static void TestIdentical() | |
| 813 { | |
| 814 int32_t i; | |
| 815 int32_t len; | |
| 816 UCollator *myCollation; | |
| 817 UErrorCode status=U_ZERO_ERROR; | |
| 818 static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 &
Ampersand; '&' & Two, 2 "; | |
| 819 UChar rules[sizeof(str)]; | |
| 820 len = strlen(str); | |
| 821 u_uastrcpy(rules, str); | |
| 822 | |
| 823 myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_IDENTICAL, NULL,&statu
s); | |
| 824 if(U_FAILURE(status)){ | |
| 825 log_err_status(status, "ERROR: in creation of rule based collator :%s\n"
, myErrorName(status)); | |
| 826 return; | |
| 827 } | |
| 828 for(i= 34; i<37; i++) | |
| 829 { | |
| 830 doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]); | |
| 831 } | |
| 832 ucol_close(myCollation); | |
| 833 myCollation = 0; | |
| 834 } | |
| 835 | |
| 836 static void TestExtra() | |
| 837 { | |
| 838 int32_t i, j; | |
| 839 int32_t len; | |
| 840 UCollator *myCollation; | |
| 841 UErrorCode status = U_ZERO_ERROR; | |
| 842 static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 &
Ampersand; '&' & Two, 2 "; | |
| 843 UChar rules[sizeof(str)]; | |
| 844 len = strlen(str); | |
| 845 u_uastrcpy(rules, str); | |
| 846 | |
| 847 myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL,
&status); | |
| 848 if(U_FAILURE(status)){ | |
| 849 log_err_status(status, "ERROR: in creation of rule based collator :%s\n"
, myErrorName(status)); | |
| 850 return; | |
| 851 } | |
| 852 ucol_setStrength(myCollation, UCOL_TERTIARY); | |
| 853 for (i = 0; i < COUNT_TEST_CASES-1 ; i++) | |
| 854 { | |
| 855 for (j = i + 1; j < COUNT_TEST_CASES; j += 1) | |
| 856 { | |
| 857 | |
| 858 doTest(myCollation, testCases[i], testCases[j], UCOL_LESS); | |
| 859 } | |
| 860 } | |
| 861 ucol_close(myCollation); | |
| 862 myCollation = 0; | |
| 863 } | |
| 864 | |
| 865 static void TestJB581(void) | |
| 866 { | |
| 867 int32_t bufferLen = 0; | |
| 868 UChar source [100]; | |
| 869 UChar target [100]; | |
| 870 UCollationResult result = UCOL_EQUAL; | |
| 871 uint8_t sourceKeyArray [100]; | |
| 872 uint8_t targetKeyArray [100]; | |
| 873 int32_t sourceKeyOut = 0, | |
| 874 targetKeyOut = 0; | |
| 875 UCollator *myCollator = 0; | |
| 876 UErrorCode status = U_ZERO_ERROR; | |
| 877 | |
| 878 /*u_uastrcpy(source, "This is a test.");*/ | |
| 879 /*u_uastrcpy(target, "THISISATEST.");*/ | |
| 880 u_uastrcpy(source, "THISISATEST."); | |
| 881 u_uastrcpy(target, "Thisisatest."); | |
| 882 | |
| 883 myCollator = ucol_open("en_US", &status); | |
| 884 if (U_FAILURE(status)){ | |
| 885 log_err_status(status, "ERROR: Failed to create the collator : %s\n", u_
errorName(status)); | |
| 886 return; | |
| 887 } | |
| 888 result = ucol_strcoll(myCollator, source, -1, target, -1); | |
| 889 /* result is 1, secondary differences only for ignorable space characters*/ | |
| 890 if (result != 1) | |
| 891 { | |
| 892 log_err("Comparing two strings with only secondary differences in C fail
ed.\n"); | |
| 893 } | |
| 894 /* To compare them with just primary differences */ | |
| 895 ucol_setStrength(myCollator, UCOL_PRIMARY); | |
| 896 result = ucol_strcoll(myCollator, source, -1, target, -1); | |
| 897 /* result is 0 */ | |
| 898 if (result != 0) | |
| 899 { | |
| 900 log_err("Comparing two strings with no differences in C failed.\n"); | |
| 901 } | |
| 902 /* Now, do the same comparison with keys */ | |
| 903 sourceKeyOut = ucol_getSortKey(myCollator, source, -1, sourceKeyArray, 100); | |
| 904 (void)sourceKeyOut; /* Suppress set but not used warning. */ | |
| 905 targetKeyOut = ucol_getSortKey(myCollator, target, -1, targetKeyArray, 100); | |
| 906 bufferLen = ((targetKeyOut > 100) ? 100 : targetKeyOut); | |
| 907 if (memcmp(sourceKeyArray, targetKeyArray, bufferLen) != 0) | |
| 908 { | |
| 909 log_err("Comparing two strings with sort keys in C failed.\n"); | |
| 910 } | |
| 911 ucol_close(myCollator); | |
| 912 } | |
| 913 | |
| 914 static void TestJB1401(void) | |
| 915 { | |
| 916 UCollator *myCollator = 0; | |
| 917 UErrorCode status = U_ZERO_ERROR; | |
| 918 static UChar NFD_UnsafeStartChars[] = { | |
| 919 0x0f73, /* Tibetan Vowel Sign II */ | |
| 920 0x0f75, /* Tibetan Vowel Sign UU */ | |
| 921 0x0f81, /* Tibetan Vowel Sign Reversed II */ | |
| 922 0 | |
| 923 }; | |
| 924 int i; | |
| 925 | |
| 926 | |
| 927 myCollator = ucol_open("en_US", &status); | |
| 928 if (U_FAILURE(status)){ | |
| 929 log_err_status(status, "ERROR: Failed to create the collator : %s\n", u_
errorName(status)); | |
| 930 return; | |
| 931 } | |
| 932 ucol_setAttribute(myCollator, UCOL_NORMALIZATION_MODE, UCOL_ON, &status); | |
| 933 if (U_FAILURE(status)){ | |
| 934 log_err("ERROR: Failed to set normalization mode ON for collator.\n"); | |
| 935 return; | |
| 936 } | |
| 937 | |
| 938 for (i=0; ; i++) { | |
| 939 UChar c; | |
| 940 UChar X[4]; | |
| 941 UChar Y[20]; | |
| 942 UChar Z[20]; | |
| 943 | |
| 944 /* Get the next funny character to be tested, and set up the | |
| 945 * three test strings X, Y, Z, consisting of an A-grave + test char, | |
| 946 * in original form, NFD, and then NFC form. | |
| 947 */ | |
| 948 c = NFD_UnsafeStartChars[i]; | |
| 949 if (c==0) {break;} | |
| 950 | |
| 951 X[0]=0xC0; X[1]=c; X[2]=0; /* \u00C0 is A Grave*/ | |
| 952 | |
| 953 unorm_normalize(X, -1, UNORM_NFD, 0, Y, 20, &status); | |
| 954 unorm_normalize(Y, -1, UNORM_NFC, 0, Z, 20, &status); | |
| 955 if (U_FAILURE(status)){ | |
| 956 log_err("ERROR: Failed to normalize test of character %x\n", c); | |
| 957 return; | |
| 958 } | |
| 959 | |
| 960 /* Collation test. All three strings should be equal. | |
| 961 * doTest does both strcoll and sort keys, with params in both orders. | |
| 962 */ | |
| 963 doTest(myCollator, X, Y, UCOL_EQUAL); | |
| 964 doTest(myCollator, X, Z, UCOL_EQUAL); | |
| 965 doTest(myCollator, Y, Z, UCOL_EQUAL); | |
| 966 | |
| 967 /* Run collation element iterators over the three strings. Results shou
ld be same for each. | |
| 968 */ | |
| 969 { | |
| 970 UCollationElements *ceiX, *ceiY, *ceiZ; | |
| 971 int32_t ceX, ceY, ceZ; | |
| 972 int j; | |
| 973 | |
| 974 ceiX = ucol_openElements(myCollator, X, -1, &status); | |
| 975 ceiY = ucol_openElements(myCollator, Y, -1, &status); | |
| 976 ceiZ = ucol_openElements(myCollator, Z, -1, &status); | |
| 977 if (U_FAILURE(status)) { | |
| 978 log_err("ERROR: uucol_openElements failed.\n"); | |
| 979 return; | |
| 980 } | |
| 981 | |
| 982 for (j=0;; j++) { | |
| 983 ceX = ucol_next(ceiX, &status); | |
| 984 ceY = ucol_next(ceiY, &status); | |
| 985 ceZ = ucol_next(ceiZ, &status); | |
| 986 if (U_FAILURE(status)) { | |
| 987 log_err("ERROR: ucol_next failed for iteration #%d.\n", j); | |
| 988 break; | |
| 989 } | |
| 990 if (ceX != ceY || ceY != ceZ) { | |
| 991 log_err("ERROR: ucol_next failed for iteration #%d.\n", j); | |
| 992 break; | |
| 993 } | |
| 994 if (ceX == UCOL_NULLORDER) { | |
| 995 break; | |
| 996 } | |
| 997 } | |
| 998 ucol_closeElements(ceiX); | |
| 999 ucol_closeElements(ceiY); | |
| 1000 ucol_closeElements(ceiZ); | |
| 1001 } | |
| 1002 } | |
| 1003 ucol_close(myCollator); | |
| 1004 } | |
| 1005 | |
| 1006 | |
| 1007 | |
| 1008 /** | |
| 1009 * Tests the [variable top] tag in rule syntax. Since the default [alternate] | |
| 1010 * tag has the value shifted, any codepoints before [variable top] should give | |
| 1011 * a primary ce of 0. | |
| 1012 */ | |
| 1013 static void TestVariableTop(void) | |
| 1014 { | |
| 1015 #if 0 | |
| 1016 /* | |
| 1017 * Starting with ICU 53, setting the variable top via a pseudo relation stri
ng | |
| 1018 * is not supported any more. | |
| 1019 * It was replaced by the [maxVariable symbol] setting. | |
| 1020 * See ICU tickets #9958 and #8032. | |
| 1021 */ | |
| 1022 static const char str[] = "&z = [variable top]"; | |
| 1023 int len = strlen(str); | |
| 1024 UChar rules[sizeof(str)]; | |
| 1025 UCollator *myCollation; | |
| 1026 UCollator *enCollation; | |
| 1027 UErrorCode status = U_ZERO_ERROR; | |
| 1028 UChar source[1]; | |
| 1029 UChar ch; | |
| 1030 uint8_t result[20]; | |
| 1031 uint8_t expected[20]; | |
| 1032 | |
| 1033 u_uastrcpy(rules, str); | |
| 1034 | |
| 1035 enCollation = ucol_open("en_US", &status); | |
| 1036 if (U_FAILURE(status)) { | |
| 1037 log_err_status(status, "ERROR: in creation of collator :%s\n", | |
| 1038 myErrorName(status)); | |
| 1039 return; | |
| 1040 } | |
| 1041 myCollation = ucol_openRules(rules, len, UCOL_OFF, | |
| 1042 UCOL_PRIMARY,NULL, &status); | |
| 1043 if (U_FAILURE(status)) { | |
| 1044 ucol_close(enCollation); | |
| 1045 log_err("ERROR: in creation of rule based collator :%s\n", | |
| 1046 myErrorName(status)); | |
| 1047 return; | |
| 1048 } | |
| 1049 | |
| 1050 ucol_setStrength(enCollation, UCOL_PRIMARY); | |
| 1051 ucol_setAttribute(enCollation, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, | |
| 1052 &status); | |
| 1053 ucol_setAttribute(myCollation, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, | |
| 1054 &status); | |
| 1055 | |
| 1056 if (ucol_getAttribute(myCollation, UCOL_ALTERNATE_HANDLING, &status) != | |
| 1057 UCOL_SHIFTED || U_FAILURE(status)) { | |
| 1058 log_err("ERROR: ALTERNATE_HANDLING value can not be set to SHIFTED\n"); | |
| 1059 } | |
| 1060 | |
| 1061 uprv_memset(expected, 0, 20); | |
| 1062 | |
| 1063 /* space is supposed to be a variable */ | |
| 1064 source[0] = ' '; | |
| 1065 len = ucol_getSortKey(enCollation, source, 1, result, | |
| 1066 sizeof(result)); | |
| 1067 | |
| 1068 if (uprv_memcmp(expected, result, len) != 0) { | |
| 1069 log_err("ERROR: SHIFTED alternate does not return 0 for primary of space
\n"); | |
| 1070 } | |
| 1071 | |
| 1072 ch = 'a'; | |
| 1073 while (ch < 'z') { | |
| 1074 source[0] = ch; | |
| 1075 len = ucol_getSortKey(myCollation, source, 1, result, | |
| 1076 sizeof(result)); | |
| 1077 if (uprv_memcmp(expected, result, len) != 0) { | |
| 1078 log_err("ERROR: SHIFTED alternate does not return 0 for primary of %
c\n", | |
| 1079 ch); | |
| 1080 } | |
| 1081 ch ++; | |
| 1082 } | |
| 1083 | |
| 1084 ucol_close(enCollation); | |
| 1085 ucol_close(myCollation); | |
| 1086 enCollation = NULL; | |
| 1087 myCollation = NULL; | |
| 1088 #endif | |
| 1089 } | |
| 1090 | |
| 1091 /** | |
| 1092 * Tests surrogate support. | |
| 1093 * NOTE: This test used \\uD801\\uDC01 pair, which is now assigned to Desseret | |
| 1094 * Therefore, another (unassigned) code point was used for this test. | |
| 1095 */ | |
| 1096 static void TestSurrogates(void) | |
| 1097 { | |
| 1098 static const char str[] = | |
| 1099 "&z<'\\uD800\\uDC00'<'\\uD800\\uDC0A\\u0308'<A"; | |
| 1100 int len = strlen(str); | |
| 1101 int rlen = 0; | |
| 1102 UChar rules[sizeof(str)]; | |
| 1103 UCollator *myCollation; | |
| 1104 UCollator *enCollation; | |
| 1105 UErrorCode status = U_ZERO_ERROR; | |
| 1106 UChar source[][4] = | |
| 1107 {{'z', 0, 0}, {0xD800, 0xDC00, 0}, {0xD800, 0xDC0A, 0x0308, 0}, {0xD80
0, 0xDC02}}; | |
| 1108 UChar target[][4] = | |
| 1109 {{0xD800, 0xDC00, 0}, {0xD800, 0xDC0A, 0x0308, 0}, {'A', 0, 0}, {0xD80
0, 0xDC03}}; | |
| 1110 int count = 0; | |
| 1111 uint8_t enresult[20], myresult[20]; | |
| 1112 int enlen, mylen; | |
| 1113 | |
| 1114 /* tests for open rules with surrogate rules */ | |
| 1115 rlen = u_unescape(str, rules, len); | |
| 1116 | |
| 1117 enCollation = ucol_open("en_US", &status); | |
| 1118 if (U_FAILURE(status)) { | |
| 1119 log_err_status(status, "ERROR: in creation of collator :%s\n", | |
| 1120 myErrorName(status)); | |
| 1121 return; | |
| 1122 } | |
| 1123 myCollation = ucol_openRules(rules, rlen, UCOL_OFF, | |
| 1124 UCOL_TERTIARY,NULL, &status); | |
| 1125 if (U_FAILURE(status)) { | |
| 1126 ucol_close(enCollation); | |
| 1127 log_err("ERROR: in creation of rule based collator :%s\n", | |
| 1128 myErrorName(status)); | |
| 1129 return; | |
| 1130 } | |
| 1131 | |
| 1132 /* | |
| 1133 this test is to verify the supplementary sort key order in the english | |
| 1134 collator | |
| 1135 */ | |
| 1136 log_verbose("start of english collation supplementary characters test\n"); | |
| 1137 while (count < 2) { | |
| 1138 doTest(enCollation, source[count], target[count], UCOL_LESS); | |
| 1139 count ++; | |
| 1140 } | |
| 1141 doTest(enCollation, source[count], target[count], UCOL_GREATER); | |
| 1142 | |
| 1143 log_verbose("start of tailored collation supplementary characters test\n"); | |
| 1144 count = 0; | |
| 1145 /* tests getting collation elements for surrogates for tailored rules */ | |
| 1146 while (count < 4) { | |
| 1147 doTest(myCollation, source[count], target[count], UCOL_LESS); | |
| 1148 count ++; | |
| 1149 } | |
| 1150 | |
| 1151 /* tests that \uD800\uDC02 still has the same value, not changed */ | |
| 1152 enlen = ucol_getSortKey(enCollation, source[3], 2, enresult, 20); | |
| 1153 mylen = ucol_getSortKey(myCollation, source[3], 2, myresult, 20); | |
| 1154 if (enlen != mylen || | |
| 1155 uprv_memcmp(enresult, myresult, enlen) != 0) { | |
| 1156 log_verbose("Failed : non-tailored supplementary characters should have
the same value\n"); | |
| 1157 } | |
| 1158 | |
| 1159 ucol_close(enCollation); | |
| 1160 ucol_close(myCollation); | |
| 1161 enCollation = NULL; | |
| 1162 myCollation = NULL; | |
| 1163 } | |
| 1164 | |
| 1165 /* | |
| 1166 *### TODO: Add more invalid rules to test all different scenarios. | |
| 1167 * | |
| 1168 */ | |
| 1169 static void | |
| 1170 TestInvalidRules(){ | |
| 1171 #define MAX_ERROR_STATES 2 | |
| 1172 | |
| 1173 static const char* rulesArr[MAX_ERROR_STATES] = { | |
| 1174 "& C < ch, cH, Ch[this should fail]<d", | |
| 1175 "& C < ch, cH, & Ch[variable top]" | |
| 1176 }; | |
| 1177 static const char* preContextArr[MAX_ERROR_STATES] = { | |
| 1178 " C < ch, cH, Ch", | |
| 1179 "& C < ch, cH", | |
| 1180 | |
| 1181 }; | |
| 1182 static const char* postContextArr[MAX_ERROR_STATES] = { | |
| 1183 "[this should fa", | |
| 1184 ", & Ch[variable" | |
| 1185 }; | |
| 1186 int i; | |
| 1187 | |
| 1188 for(i = 0;i<MAX_ERROR_STATES;i++){ | |
| 1189 UChar rules[1000] = { '\0' }; | |
| 1190 UChar preContextExp[1000] = { '\0' }; | |
| 1191 UChar postContextExp[1000] = { '\0' }; | |
| 1192 UParseError parseError; | |
| 1193 UErrorCode status = U_ZERO_ERROR; | |
| 1194 UCollator* coll=0; | |
| 1195 u_charsToUChars(rulesArr[i],rules,uprv_strlen(rulesArr[i])+1); | |
| 1196 u_charsToUChars(preContextArr[i],preContextExp,uprv_strlen(preContextArr
[i])+1); | |
| 1197 u_charsToUChars(postContextArr[i],postContextExp,uprv_strlen(postContext
Arr[i])+1); | |
| 1198 /* clean up stuff in parseError */ | |
| 1199 u_memset(parseError.preContext,0x0000,U_PARSE_CONTEXT_LEN); | |
| 1200 u_memset(parseError.postContext,0x0000,U_PARSE_CONTEXT_LEN); | |
| 1201 /* open the rules and test */ | |
| 1202 coll = ucol_openRules(rules,u_strlen(rules),UCOL_OFF,UCOL_DEFAULT_STRENG
TH,&parseError,&status); | |
| 1203 (void)coll; /* Suppress set but not used warning. */ | |
| 1204 if(u_strcmp(parseError.preContext,preContextExp)!=0){ | |
| 1205 log_err_status(status, "preContext in UParseError for ucol_openRules
does not match: \"%s\"\n", | |
| 1206 aescstrdup(parseError.preContext, -1)); | |
| 1207 } | |
| 1208 if(u_strcmp(parseError.postContext,postContextExp)!=0){ | |
| 1209 log_err_status(status, "postContext in UParseError for ucol_openRule
s does not match: \"%s\"\n", | |
| 1210 aescstrdup(parseError.postContext, -1)); | |
| 1211 } | |
| 1212 } | |
| 1213 } | |
| 1214 | |
| 1215 static void | |
| 1216 TestJitterbug1098(){ | |
| 1217 UChar rule[1000]; | |
| 1218 UCollator* c1 = NULL; | |
| 1219 UErrorCode status = U_ZERO_ERROR; | |
| 1220 UParseError parseError; | |
| 1221 char preContext[200]={0}; | |
| 1222 char postContext[200]={0}; | |
| 1223 int i=0; | |
| 1224 const char* rules[] = { | |
| 1225 "&''<\\\\", | |
| 1226 "&\\'<\\\\", | |
| 1227 "&\\\"<'\\'", | |
| 1228 "&'\"'<\\'", | |
| 1229 NULL | |
| 1230 | |
| 1231 }; | |
| 1232 const UCollationResult results1098[] = { | |
| 1233 UCOL_LESS, | |
| 1234 UCOL_LESS, | |
| 1235 UCOL_LESS, | |
| 1236 UCOL_LESS, | |
| 1237 }; | |
| 1238 const UChar input[][2]= { | |
| 1239 {0x0027,0x005c}, | |
| 1240 {0x0027,0x005c}, | |
| 1241 {0x0022,0x005c}, | |
| 1242 {0x0022,0x0027}, | |
| 1243 }; | |
| 1244 UChar X[2] ={0}; | |
| 1245 UChar Y[2] ={0}; | |
| 1246 u_memset(parseError.preContext,0x0000,U_PARSE_CONTEXT_LEN); | |
| 1247 u_memset(parseError.postContext,0x0000,U_PARSE_CONTEXT_LEN); | |
| 1248 for(;rules[i]!=0;i++){ | |
| 1249 u_uastrcpy(rule, rules[i]); | |
| 1250 c1 = ucol_openRules(rule, u_strlen(rule), UCOL_OFF, UCOL_DEFAULT_STRENGT
H, &parseError, &status); | |
| 1251 if(U_FAILURE(status)){ | |
| 1252 log_err_status(status, "Could not parse the rules syntax. Error: %s\
n", u_errorName(status)); | |
| 1253 | |
| 1254 if (status == U_PARSE_ERROR) { | |
| 1255 u_UCharsToChars(parseError.preContext,preContext,20); | |
| 1256 u_UCharsToChars(parseError.postContext,postContext,20); | |
| 1257 log_verbose("\n\tPre-Context: %s \n\tPost-Context:%s \n",preCont
ext,postContext); | |
| 1258 } | |
| 1259 | |
| 1260 return; | |
| 1261 } | |
| 1262 X[0] = input[i][0]; | |
| 1263 Y[0] = input[i][1]; | |
| 1264 doTest(c1,X,Y,results1098[i]); | |
| 1265 ucol_close(c1); | |
| 1266 } | |
| 1267 } | |
| 1268 | |
| 1269 static void | |
| 1270 TestFCDCrash(void) { | |
| 1271 static const char *test[] = { | |
| 1272 "Gr\\u00F6\\u00DFe", | |
| 1273 "Grossist" | |
| 1274 }; | |
| 1275 | |
| 1276 UErrorCode status = U_ZERO_ERROR; | |
| 1277 UCollator *coll = ucol_open("es", &status); | |
| 1278 if(U_FAILURE(status)) { | |
| 1279 log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(sta
tus)); | |
| 1280 return; | |
| 1281 } | |
| 1282 ucol_close(coll); | |
| 1283 coll = NULL; | |
| 1284 ctest_resetICU(); | |
| 1285 coll = ucol_open("de_DE", &status); | |
| 1286 if(U_FAILURE(status)) { | |
| 1287 log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(sta
tus)); | |
| 1288 return; | |
| 1289 } | |
| 1290 ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status); | |
| 1291 genericOrderingTest(coll, test, 2); | |
| 1292 ucol_close(coll); | |
| 1293 } | |
| 1294 | |
| 1295 /*static UBool | |
| 1296 find(UEnumeration* list, const char* str, UErrorCode* status){ | |
| 1297 const char* value = NULL; | |
| 1298 int32_t length=0; | |
| 1299 if(U_FAILURE(*status)){ | |
| 1300 return FALSE; | |
| 1301 } | |
| 1302 uenum_reset(list, status); | |
| 1303 while( (value= uenum_next(list, &length, status))!=NULL){ | |
| 1304 if(strcmp(value, str)==0){ | |
| 1305 return TRUE; | |
| 1306 } | |
| 1307 } | |
| 1308 return FALSE; | |
| 1309 }*/ | |
| 1310 | |
| 1311 static void TestJ5298(void) | |
| 1312 { | |
| 1313 UErrorCode status = U_ZERO_ERROR; | |
| 1314 char input[256], output[256]; | |
| 1315 UBool isAvailable; | |
| 1316 int32_t i = 0; | |
| 1317 UEnumeration* values = NULL; | |
| 1318 const char *keywordValue = NULL; | |
| 1319 log_verbose("Number of collator locales returned : %i \n", ucol_countAvailab
le()); | |
| 1320 values = ucol_getKeywordValues("collation", &status); | |
| 1321 while ((keywordValue = uenum_next(values, NULL, &status)) != NULL) { | |
| 1322 if (strncmp(keywordValue, "private-", 8) == 0) { | |
| 1323 log_err("ucol_getKeywordValues() returns private collation keyword:
%s\n", keywordValue); | |
| 1324 } | |
| 1325 } | |
| 1326 for (i = 0; i < ucol_countAvailable(); i++) { | |
| 1327 uenum_reset(values, &status); | |
| 1328 while ((keywordValue = uenum_next(values, NULL, &status)) != NULL) { | |
| 1329 strcpy(input, ucol_getAvailable(i)); | |
| 1330 if (strcmp(keywordValue, "standard") != 0) { | |
| 1331 strcat(input, "@collation="); | |
| 1332 strcat(input, keywordValue); | |
| 1333 } | |
| 1334 | |
| 1335 ucol_getFunctionalEquivalent(output, 256, "collation", input, &isAva
ilable, &status); | |
| 1336 if (strcmp(input, output) == 0) { /* Unique locale, print it out */ | |
| 1337 log_verbose("%s, \n", output); | |
| 1338 } | |
| 1339 } | |
| 1340 } | |
| 1341 uenum_close(values); | |
| 1342 log_verbose("\n"); | |
| 1343 } | |
| 1344 #endif /* #if !UCONFIG_NO_COLLATION */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
