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