]> git.saurik.com Git - apple/icu.git/blame - icuSources/test/cintltst/trietest.c
projects / apple / icu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ICU-511.35.tar.gz
[apple/icu.git] / icuSources / test / cintltst / trietest.c
CommitLineData
b75a7d8f
A		 1/*
2******************************************************************************
3*
4388f060 4* Copyright (C) 2001-2011, International Business Machines
b75a7d8f
A		 5* Corporation and others. All Rights Reserved.
6*
7******************************************************************************
8* file name: trietest.c
9* encoding: US-ASCII
10* tab size: 8 (not used)
11* indentation:4
12*
13* created on: 2001nov20
14* created by: Markus W. Scherer
15*/
16
17#include <stdio.h>
18#include "unicode/utypes.h"
4388f060 19#include "unicode/utf16.h"
b75a7d8f
A		 20#include "utrie.h"
21#include "cstring.h"
22#include "cmemory.h"
23
24#if 1
25#include "cintltst.h"
26#else
27/* definitions from standalone utrie development */
28#define log_err printf
29#define log_verbose printf
30
31#undef u_errorName
32#define u_errorName(errorCode) "some error code"
33#endif
34
35#define ARRAY_LENGTH(array) (sizeof(array)/sizeof(array[0]))
36
37/* Values for setting possibly overlapping, out-of-order ranges of values */
38typedef struct SetRange {
39 UChar32 start, limit;
40 uint32_t value;
41 UBool overwrite;
42} SetRange;
43
44/*
45 * Values for testing:
46 * value is set from the previous boundary's limit to before
47 * this boundary's limit
48 */
49typedef struct CheckRange {
50 UChar32 limit;
51 uint32_t value;
52} CheckRange;
b75a7d8f
A		 53
54
55static uint32_t U_CALLCONV
56_testFoldedValue32(UNewTrie *trie, UChar32 start, int32_t offset) {
57 uint32_t foldedValue, value;
58 UChar32 limit;
59 UBool inBlockZero;
60
61 foldedValue=0;
62
63 limit=start+0x400;
64 while(start<limit) {
65 value=utrie_get32(trie, start, &inBlockZero);
66 if(inBlockZero) {
67 start+=UTRIE_DATA_BLOCK_LENGTH;
68 } else {
69 foldedValue|=value;
70 ++start;
71 }
72 }
73
74 if(foldedValue!=0) {
75 return ((uint32_t)offset<<16)|foldedValue;
76 } else {
77 return 0;
78 }
79}
80
81static int32_t U_CALLCONV
82_testFoldingOffset32(uint32_t data) {
83 return (int32_t)(data>>16);
84}
85
86static uint32_t U_CALLCONV
87_testFoldedValue16(UNewTrie *trie, UChar32 start, int32_t offset) {
88 uint32_t foldedValue, value;
89 UChar32 limit;
90 UBool inBlockZero;
91
92 foldedValue=0;
93
94 limit=start+0x400;
95 while(start<limit) {
96 value=utrie_get32(trie, start, &inBlockZero);
97 if(inBlockZero) {
98 start+=UTRIE_DATA_BLOCK_LENGTH;
99 } else {
100 foldedValue|=value;
101 ++start;
102 }
103 }
104
105 if(foldedValue!=0) {
106 return (uint32_t)(offset|0x8000);
107 } else {
108 return 0;
109 }
110}
111
112static int32_t U_CALLCONV
113_testFoldingOffset16(uint32_t data) {
114 if(data&0x8000) {
115 return (int32_t)(data&0x7fff);
116 } else {
117 return 0;
118 }
119}
120
121static uint32_t U_CALLCONV
122_testEnumValue(const void *context, uint32_t value) {
123 return value^0x5555;
124}
125
126static UBool U_CALLCONV
127_testEnumRange(const void *context, UChar32 start, UChar32 limit, uint32_t value) {
128 const CheckRange **pb=(const CheckRange **)context;
129 const CheckRange *b=(*pb)++;
130
131 value^=0x5555;
132 if(start!=(b-1)->limit || limit!=b->limit || value!=b->value) {
133 log_err("error: utrie_enum() delivers wrong range [U+%04lx..U+%04lx[.0x%lx instead of [U+%04lx..U+%04lx[.0x%lx\n",
134 start, limit, value,
135 (b-1)->limit, b->limit, b->value);
136 }
137 return TRUE;
138}
139
140static void
141testTrieIteration(const char *testName,
142 const UTrie *trie,
143 const CheckRange checkRanges[], int32_t countCheckRanges) {
144 UChar s[100];
145 uint32_t values[30];
146
147 const UChar *p, *limit;
148
149 uint32_t value;
150 UChar32 c;
151 int32_t i, length, countValues;
152 UChar c2;
153
154 /* write a string */
155 length=countValues=0;
156 for(i=0; i<countCheckRanges; ++i) {
157 c=checkRanges[i].limit;
158 if(c!=0) {
159 --c;
4388f060 160 U16_APPEND_UNSAFE(s, length, c);
b75a7d8f
A		 161 values[countValues++]=checkRanges[i].value;
162 }
163 }
164 limit=s+length;
165
166 /* try forward */
167 p=s;
168 i=0;
169 while(p<limit) {
170 c=c2=0x33;
171 if(trie->data32!=NULL) {
172 UTRIE_NEXT32(trie, p, limit, c, c2, value);
173 } else {
174 UTRIE_NEXT16(trie, p, limit, c, c2, value);
175 }
176 if(value!=values[i]) {
177 log_err("error: wrong value from UTRIE_NEXT(%s)(U+%04lx, U+%04lx): 0x%lx instead of 0x%lx\n",
178 testName, c, c2, value, values[i]);
179 }
180 if(
181 c2==0 ?
182 c!=*(p-1) :
4388f060 183 !U16_IS_LEAD(c) || !U16_IS_TRAIL(c2) || c!=*(p-2) || c2!=*(p-1)
b75a7d8f
A		 184 ) {
185 log_err("error: wrong (c, c2) from UTRIE_NEXT(%s): (U+%04lx, U+%04lx)\n",
186 testName, c, c2);
187 continue;
188 }
189 if(c2!=0) {
190 int32_t offset;
191
192 if(trie->data32==NULL) {
193 value=UTRIE_GET16_FROM_LEAD(trie, c);
194 offset=trie->getFoldingOffset(value);
195 if(offset>0) {
196 value=UTRIE_GET16_FROM_OFFSET_TRAIL(trie, offset, c2);
197 } else {
198 value=trie->initialValue;
199 }
200 } else {
201 value=UTRIE_GET32_FROM_LEAD(trie, c);
202 offset=trie->getFoldingOffset(value);
203 if(offset>0) {
204 value=UTRIE_GET32_FROM_OFFSET_TRAIL(trie, offset, c2);
205 } else {
206 value=trie->initialValue;
207 }
208 }
209 if(value!=values[i]) {
210 log_err("error: wrong value from UTRIE_GETXX_FROM_OFFSET_TRAIL(%s)(U+%04lx, U+%04lx): 0x%lx instead of 0x%lx\n",
211 testName, c, c2, value, values[i]);
212 }
213 }
214 if(c2!=0) {
215 value=0x44;
216 if(trie->data32==NULL) {
217 UTRIE_GET16_FROM_PAIR(trie, c, c2, value);
218 } else {
219 UTRIE_GET32_FROM_PAIR(trie, c, c2, value);
220 }
221 if(value!=values[i]) {
222 log_err("error: wrong value from UTRIE_GETXX_FROM_PAIR(%s)(U+%04lx, U+%04lx): 0x%lx instead of 0x%lx\n",
223 testName, c, c2, value, values[i]);
224 }
225 }
226 ++i;
227 }
228
229 /* try backward */
230 p=limit;
231 i=countValues;
232 while(s<p) {
233 --i;
234 c=c2=0x33;
235 if(trie->data32!=NULL) {
236 UTRIE_PREVIOUS32(trie, s, p, c, c2, value);
237 } else {
238 UTRIE_PREVIOUS16(trie, s, p, c, c2, value);
239 }
240 if(value!=values[i]) {
241 log_err("error: wrong value from UTRIE_PREVIOUS(%s)(U+%04lx, U+%04lx): 0x%lx instead of 0x%lx\n",
242 testName, c, c2, value, values[i]);
243 }
244 if(
245 c2==0 ?
246 c!=*p:
4388f060 247 !U16_IS_LEAD(c) || !U16_IS_TRAIL(c2) || c!=*p || c2!=*(p+1)
b75a7d8f
A		 248 ) {
249 log_err("error: wrong (c, c2) from UTRIE_PREVIOUS(%s): (U+%04lx, U+%04lx)\n",
250 testName, c, c2);
251 }
252 }
253}
254
255static void
256testTrieRangesWithMalloc(const char *testName,
257 const SetRange setRanges[], int32_t countSetRanges,
258 const CheckRange checkRanges[], int32_t countCheckRanges,
259 UBool dataIs32, UBool latin1Linear) {
260 UTrieGetFoldingOffset *getFoldingOffset;
261 const CheckRange *enumRanges;
262 UNewTrie *newTrie;
263 UTrie trie={ 0 };
264 uint32_t value, value2;
265 UChar32 start, limit;
266 int32_t i, length;
267 UErrorCode errorCode;
268 UBool overwrite, ok;
269 uint8_t* storage =NULL;
46f4442e
A		 270 static const int32_t DEFAULT_STORAGE_SIZE = 32768;
271 storage = (uint8_t*) uprv_malloc(sizeof(uint8_t)*DEFAULT_STORAGE_SIZE);
b75a7d8f
A		 272
273 log_verbose("\ntesting Trie '%s'\n", testName);
374ca955
A		 274 newTrie=utrie_open(NULL, NULL, 2000,
275 checkRanges[0].value, checkRanges[0].value,
276 latin1Linear);
b75a7d8f
A		 277
278 /* set values from setRanges[] */
279 ok=TRUE;
280 for(i=0; i<countSetRanges; ++i) {
281 start=setRanges[i].start;
282 limit=setRanges[i].limit;
283 value=setRanges[i].value;
284 overwrite=setRanges[i].overwrite;
285 if((limit-start)==1 && overwrite) {
286 ok&=utrie_set32(newTrie, start, value);
287 } else {
288 ok&=utrie_setRange32(newTrie, start, limit, value, overwrite);
289 }
290 }
291 if(!ok) {
292 log_err("error: setting values into a trie failed (%s)\n", testName);
293 return;
294 }
295
296 /* verify that all these values are in the new Trie */
297 start=0;
298 for(i=0; i<countCheckRanges; ++i) {
299 limit=checkRanges[i].limit;
300 value=checkRanges[i].value;
301
302 while(start<limit) {
303 if(value!=utrie_get32(newTrie, start, NULL)) {
304 log_err("error: newTrie(%s)[U+%04lx]==0x%lx instead of 0x%lx\n",
305 testName, start, utrie_get32(newTrie, start, NULL), value);
306 }
307 ++start;
308 }
309 }
310
311 if(dataIs32) {
312 getFoldingOffset=_testFoldingOffset32;
313 } else {
314 getFoldingOffset=_testFoldingOffset16;
315 }
316
317 errorCode=U_ZERO_ERROR;
46f4442e 318 length=utrie_serialize(newTrie, storage, DEFAULT_STORAGE_SIZE,
b75a7d8f
A		 319 dataIs32 ? _testFoldedValue32 : _testFoldedValue16,
320 (UBool)!dataIs32,
321 &errorCode);
322 if(U_FAILURE(errorCode)) {
323 log_err("error: utrie_serialize(%s) failed: %s\n", testName, u_errorName(errorCode));
324 utrie_close(newTrie);
325 return;
326 }
327
328 /* test linear Latin-1 range from utrie_getData() */
329 if(latin1Linear) {
330 uint32_t *data;
331 int32_t dataLength;
332
333 data=utrie_getData(newTrie, &dataLength);
334 start=0;
335 for(i=0; i<countCheckRanges && start<=0xff; ++i) {
336 limit=checkRanges[i].limit;
337 value=checkRanges[i].value;
338
339 while(start<limit && start<=0xff) {
340 if(value!=data[UTRIE_DATA_BLOCK_LENGTH+start]) {
341 log_err("error: newTrie(%s).latin1Data[U+%04lx]==0x%lx instead of 0x%lx\n",
342 testName, start, data[UTRIE_DATA_BLOCK_LENGTH+start], value);
343 }
344 ++start;
345 }
346 }
347 }
348
349 utrie_close(newTrie);
350
351 errorCode=U_ZERO_ERROR;
352 if(!utrie_unserialize(&trie, storage, length, &errorCode)) {
353 log_err("error: utrie_unserialize() failed, %s\n", u_errorName(errorCode));
354 return;
355 }
356 trie.getFoldingOffset=getFoldingOffset;
357
358 if(dataIs32!=(trie.data32!=NULL)) {
359 log_err("error: trie serialization (%s) did not preserve 32-bitness\n", testName);
360 }
361 if(latin1Linear!=trie.isLatin1Linear) {
362 log_err("error: trie serialization (%s) did not preserve Latin-1-linearity\n", testName);
363 }
364
365 /* verify that all these values are in the unserialized Trie */
366 start=0;
367 for(i=0; i<countCheckRanges; ++i) {
368 limit=checkRanges[i].limit;
369 value=checkRanges[i].value;
370
371 if(start==0xd800) {
372 /* skip surrogates */
373 start=limit;
374 continue;
375 }
376
377 while(start<limit) {
378 if(start<=0xffff) {
379 if(dataIs32) {
380 value2=UTRIE_GET32_FROM_BMP(&trie, start);
381 } else {
382 value2=UTRIE_GET16_FROM_BMP(&trie, start);
383 }
384 if(value!=value2) {
385 log_err("error: unserialized trie(%s).fromBMP(U+%04lx)==0x%lx instead of 0x%lx\n",
386 testName, start, value2, value);
387 }
4388f060 388 if(!U16_IS_LEAD(start)) {
b75a7d8f
A		 389 if(dataIs32) {
390 value2=UTRIE_GET32_FROM_LEAD(&trie, start);
391 } else {
392 value2=UTRIE_GET16_FROM_LEAD(&trie, start);
393 }
394 if(value!=value2) {
395 log_err("error: unserialized trie(%s).fromLead(U+%04lx)==0x%lx instead of 0x%lx\n",
396 testName, start, value2, value);
397 }
398 }
399 }
400 if(dataIs32) {
401 UTRIE_GET32(&trie, start, value2);
402 } else {
403 UTRIE_GET16(&trie, start, value2);
404 }
405 if(value!=value2) {
406 log_err("error: unserialized trie(%s).get(U+%04lx)==0x%lx instead of 0x%lx\n",
407 testName, start, value2, value);
408 }
409 ++start;
410 }
411 }
412
413 /* enumerate and verify all ranges */
414 enumRanges=checkRanges+1;
415 utrie_enum(&trie, _testEnumValue, _testEnumRange, &enumRanges);
416
417 /* test linear Latin-1 range */
418 if(trie.isLatin1Linear) {
419 if(trie.data32!=NULL) {
420 const uint32_t *latin1=UTRIE_GET32_LATIN1(&trie);
421
422 for(start=0; start<0x100; ++start) {
423 if(latin1[start]!=UTRIE_GET32_FROM_LEAD(&trie, start)) {
424 log_err("error: (%s) trie.latin1[U+%04lx]=0x%lx!=0x%lx=trie.get32(U+%04lx)\n",
425 testName, start, latin1[start], UTRIE_GET32_FROM_LEAD(&trie, start), start);
426 }
427 }
428 } else {
429 const uint16_t *latin1=UTRIE_GET16_LATIN1(&trie);
430
431 for(start=0; start<0x100; ++start) {
432 if(latin1[start]!=UTRIE_GET16_FROM_LEAD(&trie, start)) {
433 log_err("error: (%s) trie.latin1[U+%04lx]=0x%lx!=0x%lx=trie.get16(U+%04lx)\n",
434 testName, start, latin1[start], UTRIE_GET16_FROM_LEAD(&trie, start), start);
435 }
436 }
437 }
438 }
439
440 testTrieIteration(testName, &trie, checkRanges, countCheckRanges);
441 uprv_free(storage);
442}
443
444static void
445testTrieRanges(const char *testName,
446 const SetRange setRanges[], int32_t countSetRanges,
447 const CheckRange checkRanges[], int32_t countCheckRanges,
448 UBool dataIs32, UBool latin1Linear) {
46f4442e
A		 449 union{
450 double bogus; /* needed for aligining the storage */
451 uint8_t storage[32768];
452 } storageHolder;
b75a7d8f 453 UTrieGetFoldingOffset *getFoldingOffset;
73c04bcf 454 UNewTrieGetFoldedValue *getFoldedValue;
b75a7d8f
A		 455 const CheckRange *enumRanges;
456 UNewTrie *newTrie;
457 UTrie trie={ 0 };
458 uint32_t value, value2;
459 UChar32 start, limit;
460 int32_t i, length;
461 UErrorCode errorCode;
462 UBool overwrite, ok;
463
464 log_verbose("\ntesting Trie '%s'\n", testName);
374ca955
A		 465 newTrie=utrie_open(NULL, NULL, 2000,
466 checkRanges[0].value, checkRanges[0].value,
467 latin1Linear);
b75a7d8f
A		 468
469 /* set values from setRanges[] */
470 ok=TRUE;
471 for(i=0; i<countSetRanges; ++i) {
472 start=setRanges[i].start;
473 limit=setRanges[i].limit;
474 value=setRanges[i].value;
475 overwrite=setRanges[i].overwrite;
476 if((limit-start)==1 && overwrite) {
477 ok&=utrie_set32(newTrie, start, value);
478 } else {
479 ok&=utrie_setRange32(newTrie, start, limit, value, overwrite);
480 }
481 }
482 if(!ok) {
483 log_err("error: setting values into a trie failed (%s)\n", testName);
484 return;
485 }
486
487 /* verify that all these values are in the new Trie */
488 start=0;
489 for(i=0; i<countCheckRanges; ++i) {
490 limit=checkRanges[i].limit;
491 value=checkRanges[i].value;
492
493 while(start<limit) {
494 if(value!=utrie_get32(newTrie, start, NULL)) {
495 log_err("error: newTrie(%s)[U+%04lx]==0x%lx instead of 0x%lx\n",
496 testName, start, utrie_get32(newTrie, start, NULL), value);
497 }
498 ++start;
499 }
500 }
501
502 if(dataIs32) {
503 getFoldingOffset=_testFoldingOffset32;
73c04bcf 504 getFoldedValue=_testFoldedValue32;
b75a7d8f
A		 505 } else {
506 getFoldingOffset=_testFoldingOffset16;
73c04bcf
A		 507 getFoldedValue=_testFoldedValue16;
508 }
509
510 /*
511 * code coverage for utrie.c/defaultGetFoldedValue(),
512 * pick some combination of parameters for selecting the UTrie defaults
513 */
514 if(!dataIs32 && latin1Linear) {
515 getFoldingOffset=NULL;
516 getFoldedValue=NULL;
b75a7d8f
A		 517 }
518
519 errorCode=U_ZERO_ERROR;
520 length=utrie_serialize(newTrie, storageHolder.storage, sizeof(storageHolder.storage),
73c04bcf 521 getFoldedValue,
b75a7d8f
A		 522 (UBool)!dataIs32,
523 &errorCode);
524 if(U_FAILURE(errorCode)) {
525 log_err("error: utrie_serialize(%s) failed: %s\n", testName, u_errorName(errorCode));
526 utrie_close(newTrie);
527 return;
528 }
46f4442e
A		 529 if (length >= (int32_t)sizeof(storageHolder.storage)) {
530 log_err("error: utrie_serialize(%s) needs more memory\n", testName);
531 utrie_close(newTrie);
532 return;
533 }
b75a7d8f
A		 534
535 /* test linear Latin-1 range from utrie_getData() */
536 if(latin1Linear) {
537 uint32_t *data;
538 int32_t dataLength;
539
540 data=utrie_getData(newTrie, &dataLength);
541 start=0;
542 for(i=0; i<countCheckRanges && start<=0xff; ++i) {
543 limit=checkRanges[i].limit;
544 value=checkRanges[i].value;
545
546 while(start<limit && start<=0xff) {
547 if(value!=data[UTRIE_DATA_BLOCK_LENGTH+start]) {
548 log_err("error: newTrie(%s).latin1Data[U+%04lx]==0x%lx instead of 0x%lx\n",
549 testName, start, data[UTRIE_DATA_BLOCK_LENGTH+start], value);
550 }
551 ++start;
552 }
553 }
554 }
555
556 utrie_close(newTrie);
557
558 errorCode=U_ZERO_ERROR;
559 if(!utrie_unserialize(&trie, storageHolder.storage, length, &errorCode)) {
560 log_err("error: utrie_unserialize() failed, %s\n", u_errorName(errorCode));
561 return;
562 }
73c04bcf
A		 563 if(getFoldingOffset!=NULL) {
564 trie.getFoldingOffset=getFoldingOffset;
565 }
b75a7d8f
A		 566
567 if(dataIs32!=(trie.data32!=NULL)) {
568 log_err("error: trie serialization (%s) did not preserve 32-bitness\n", testName);
569 }
570 if(latin1Linear!=trie.isLatin1Linear) {
571 log_err("error: trie serialization (%s) did not preserve Latin-1-linearity\n", testName);
572 }
573
574 /* verify that all these values are in the unserialized Trie */
575 start=0;
576 for(i=0; i<countCheckRanges; ++i) {
577 limit=checkRanges[i].limit;
578 value=checkRanges[i].value;
579
580 if(start==0xd800) {
581 /* skip surrogates */
582 start=limit;
583 continue;
584 }
585
586 while(start<limit) {
587 if(start<=0xffff) {
588 if(dataIs32) {
589 value2=UTRIE_GET32_FROM_BMP(&trie, start);
590 } else {
591 value2=UTRIE_GET16_FROM_BMP(&trie, start);
592 }
593 if(value!=value2) {
594 log_err("error: unserialized trie(%s).fromBMP(U+%04lx)==0x%lx instead of 0x%lx\n",
595 testName, start, value2, value);
596 }
4388f060 597 if(!U16_IS_LEAD(start)) {
b75a7d8f
A		 598 if(dataIs32) {
599 value2=UTRIE_GET32_FROM_LEAD(&trie, start);
600 } else {
601 value2=UTRIE_GET16_FROM_LEAD(&trie, start);
602 }
603 if(value!=value2) {
604 log_err("error: unserialized trie(%s).fromLead(U+%04lx)==0x%lx instead of 0x%lx\n",
605 testName, start, value2, value);
606 }
607 }
608 }
609 if(dataIs32) {
610 UTRIE_GET32(&trie, start, value2);
611 } else {
612 UTRIE_GET16(&trie, start, value2);
613 }
614 if(value!=value2) {
615 log_err("error: unserialized trie(%s).get(U+%04lx)==0x%lx instead of 0x%lx\n",
616 testName, start, value2, value);
617 }
618 ++start;
619 }
620 }
621
622 /* enumerate and verify all ranges */
623 enumRanges=checkRanges+1;
624 utrie_enum(&trie, _testEnumValue, _testEnumRange, &enumRanges);
625
626 /* test linear Latin-1 range */
627 if(trie.isLatin1Linear) {
628 if(trie.data32!=NULL) {
629 const uint32_t *latin1=UTRIE_GET32_LATIN1(&trie);
630
631 for(start=0; start<0x100; ++start) {
632 if(latin1[start]!=UTRIE_GET32_FROM_LEAD(&trie, start)) {
633 log_err("error: (%s) trie.latin1[U+%04lx]=0x%lx!=0x%lx=trie.get32(U+%04lx)\n",
634 testName, start, latin1[start], UTRIE_GET32_FROM_LEAD(&trie, start), start);
635 }
636 }
637 } else {
638 const uint16_t *latin1=UTRIE_GET16_LATIN1(&trie);
639
640 for(start=0; start<0x100; ++start) {
641 if(latin1[start]!=UTRIE_GET16_FROM_LEAD(&trie, start)) {
642 log_err("error: (%s) trie.latin1[U+%04lx]=0x%lx!=0x%lx=trie.get16(U+%04lx)\n",
643 testName, start, latin1[start], UTRIE_GET16_FROM_LEAD(&trie, start), start);
644 }
645 }
646 }
647 }
648
649 testTrieIteration(testName, &trie, checkRanges, countCheckRanges);
650}
651
652static void
653testTrieRanges2(const char *testName,
654 const SetRange setRanges[], int32_t countSetRanges,
655 const CheckRange checkRanges[], int32_t countCheckRanges,
656 UBool dataIs32) {
657 char name[40];
658
659 testTrieRanges(testName,
660 setRanges, countSetRanges,
661 checkRanges, countCheckRanges,
662 dataIs32, FALSE);
663 testTrieRangesWithMalloc(testName,
664 setRanges, countSetRanges,
665 checkRanges, countCheckRanges,
666 dataIs32, FALSE);
667
668 uprv_strcpy(name, testName);
669 uprv_strcat(name, "-latin1Linear");
670 testTrieRanges(name,
671 setRanges, countSetRanges,
672 checkRanges, countCheckRanges,
673 dataIs32, TRUE);
674 testTrieRangesWithMalloc(name,
675 setRanges, countSetRanges,
676 checkRanges, countCheckRanges,
677 dataIs32, TRUE);
678}
679
680static void
681testTrieRanges4(const char *testName,
682 const SetRange setRanges[], int32_t countSetRanges,
683 const CheckRange checkRanges[], int32_t countCheckRanges) {
684 char name[40];
685
686 uprv_strcpy(name, testName);
687 uprv_strcat(name, ".32");
688 testTrieRanges2(name,
689 setRanges, countSetRanges,
690 checkRanges, countCheckRanges,
691 TRUE);
692
693 uprv_strcpy(name, testName);
694 uprv_strcat(name, ".16");
695 testTrieRanges2(name,
696 setRanges, countSetRanges,
697 checkRanges, countCheckRanges,
698 FALSE);
699}
700
701/* test data ----------------------------------------------------------------*/
702
703/* set consecutive ranges, even with value 0 */
704static const SetRange
705setRanges1[]={
706 {0, 0x20, 0, FALSE},
707 {0x20, 0xa7, 0x1234, FALSE},
708 {0xa7, 0x3400, 0, FALSE},
709 {0x3400, 0x9fa6, 0x6162, FALSE},
374ca955
A		 710 {0x9fa6, 0xda9e, 0x3132, FALSE},
711 {0xdada, 0xeeee, 0x87ff, FALSE}, /* try to disrupt _testFoldingOffset16() */
b75a7d8f
A		 712 {0xeeee, 0x11111, 1, FALSE},
713 {0x11111, 0x44444, 0x6162, FALSE},
374ca955 714 {0x44444, 0x60003, 0, FALSE},
b75a7d8f
A		 715 {0xf0003, 0xf0004, 0xf, FALSE},
716 {0xf0004, 0xf0006, 0x10, FALSE},
717 {0xf0006, 0xf0007, 0x11, FALSE},
718 {0xf0007, 0xf0020, 0x12, FALSE},
719 {0xf0020, 0x110000, 0, FALSE}
720};
721
722static const CheckRange
723checkRanges1[]={
724 {0, 0}, /* dummy start range to make _testEnumRange() simpler */
725 {0x20, 0},
726 {0xa7, 0x1234},
727 {0x3400, 0},
728 {0x9fa6, 0x6162},
374ca955
A		 729 {0xda9e, 0x3132},
730 {0xdada, 0},
731 {0xeeee, 0x87ff},
b75a7d8f
A		 732 {0x11111,1},
733 {0x44444,0x6162},
734 {0xf0003,0},
735 {0xf0004,0xf},
736 {0xf0006,0x10},
737 {0xf0007,0x11},
738 {0xf0020,0x12},
739 {0x110000, 0}
740};
741
742/* set some interesting overlapping ranges */
743static const SetRange
744setRanges2[]={
745 {0x21, 0x7f, 0x5555, TRUE},
746 {0x2f800,0x2fedc, 0x7a, TRUE},
747 {0x72, 0xdd, 3, TRUE},
748 {0xdd, 0xde, 4, FALSE},
729e4ab9
A		 749 {0x201, 0x220, 6, TRUE}, /* 3 consecutive blocks with the same pattern but discontiguous value ranges */
750 {0x221, 0x240, 6, TRUE},
751 {0x241, 0x260, 6, TRUE},
b75a7d8f
A		 752 {0x2f987,0x2fa98, 5, TRUE},
753 {0x2f777,0x2f833, 0, TRUE},
754 {0x2f900,0x2ffee, 1, FALSE},
755 {0x2ffee,0x2ffef, 2, TRUE}
756};
757
758static const CheckRange
759checkRanges2[]={
760 {0, 0}, /* dummy start range to make _testEnumRange() simpler */
761 {0x21, 0},
762 {0x72, 0x5555},
763 {0xdd, 3},
764 {0xde, 4},
729e4ab9
A		 765 {0x201, 0},
766 {0x220, 6},
767 {0x221, 0},
768 {0x240, 6},
769 {0x241, 0},
770 {0x260, 6},
b75a7d8f
A		 771 {0x2f833,0},
772 {0x2f987,0x7a},
773 {0x2fa98,5},
774 {0x2fedc,0x7a},
775 {0x2ffee,1},
776 {0x2ffef,2},
777 {0x110000, 0}
778};
779
780/* use a non-zero initial value */
781static const SetRange
782setRanges3[]={
783 {0x31, 0xa4, 1, FALSE},
784 {0x3400, 0x6789, 2, FALSE},
785 {0x30000,0x34567,9, TRUE},
786 {0x45678,0x56789,3, TRUE}
787};
788
789static const CheckRange
790checkRanges3[]={
791 {0, 9}, /* dummy start range, also carries the initial value */
792 {0x31, 9},
793 {0xa4, 1},
794 {0x3400, 9},
795 {0x6789, 2},
796 {0x45678,9},
797 {0x56789,3},
798 {0x110000,9}
799};
800
801static void
802TrieTest(void) {
803 testTrieRanges4("set1",
804 setRanges1, ARRAY_LENGTH(setRanges1),
805 checkRanges1, ARRAY_LENGTH(checkRanges1));
806 testTrieRanges4("set2-overlap",
807 setRanges2, ARRAY_LENGTH(setRanges2),
808 checkRanges2, ARRAY_LENGTH(checkRanges2));
809 testTrieRanges4("set3-initial-9",
810 setRanges3, ARRAY_LENGTH(setRanges3),
811 checkRanges3, ARRAY_LENGTH(checkRanges3));
812}
813
73c04bcf
A		 814/* test utrie_unserializeDummy() -------------------------------------------- */
815
816static int32_t U_CALLCONV
817dummyGetFoldingOffset(uint32_t data) {
818 return -1; /* never get non-initialValue data for supplementary code points */
819}
820
821static void
822dummyTest(UBool make16BitTrie) {
46f4442e 823 int32_t mem[UTRIE_DUMMY_SIZE/4];
73c04bcf
A		 824
825 UTrie trie;
826 UErrorCode errorCode;
827 UChar32 c;
828
829 uint32_t value, initialValue, leadUnitValue;
830
831 if(make16BitTrie) {
832 initialValue=0x313;
833 leadUnitValue=0xaffe;
834 } else {
835 initialValue=0x01234567;
836 leadUnitValue=0x89abcdef;
837 }
838
839 errorCode=U_ZERO_ERROR;
840 utrie_unserializeDummy(&trie, mem, sizeof(mem), initialValue, leadUnitValue, make16BitTrie, &errorCode);
841 if(U_FAILURE(errorCode)) {
842 log_err("utrie_unserializeDummy(make16BitTrie=%d) failed - %s\n", make16BitTrie, u_errorName(errorCode));
843 return;
844 }
845 trie.getFoldingOffset=dummyGetFoldingOffset;
846
847 /* test that all code points have initialValue */
848 for(c=0; c<=0x10ffff; ++c) {
849 if(make16BitTrie) {
850 UTRIE_GET16(&trie, c, value);
851 } else {
852 UTRIE_GET32(&trie, c, value);
853 }
854 if(value!=initialValue) {
855 log_err("UTRIE_GET%s(dummy, U+%04lx)=0x%lx instead of 0x%lx\n",
856 make16BitTrie ? "16" : "32", (long)c, (long)value, (long)initialValue);
857 }
858 }
859
860 /* test that the lead surrogate code units have leadUnitValue */
861 for(c=0xd800; c<=0xdbff; ++c) {
862 if(make16BitTrie) {
863 value=UTRIE_GET16_FROM_LEAD(&trie, c);
864 } else {
865 value=UTRIE_GET32_FROM_LEAD(&trie, c);
866 }
867 if(value!=leadUnitValue) {
868 log_err("UTRIE_GET%s_FROM_LEAD(dummy, U+%04lx)=0x%lx instead of 0x%lx\n",
869 make16BitTrie ? "16" : "32", (long)c, (long)value, (long)leadUnitValue);
870 }
871 }
872}
873
874static void
875DummyTrieTest(void) {
876 dummyTest(TRUE);
877 dummyTest(FALSE);
878}
879
b75a7d8f
A		 880void
881addTrieTest(TestNode** root);
882
883void
884addTrieTest(TestNode** root) {
374ca955 885 addTest(root, &TrieTest, "tsutil/trietest/TrieTest");
73c04bcf 886 addTest(root, &DummyTrieTest, "tsutil/trietest/DummyTrieTest");
b75a7d8f 887}
mirror of ICU