icuSources/test/cintltst/trietest.c

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