icuSources/test/cintltst/usettest.c

   1 /*
   2 **********************************************************************
   3 * Copyright (c) 2002-2009, International Business Machines
   4 * Corporation and others.  All Rights Reserved.
   5 **********************************************************************
   6 */
   7 #include "unicode/uset.h"
   8 #include "unicode/ustring.h"
   9 #include "cintltst.h"
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
  14
  15 #define TEST(x) addTest(root, &x, "uset/" # x)
  16
  17 static void TestAPI(void);
  18 static void Testj2269(void);
  19 static void TestSerialized(void);
  20 static void TestNonInvariantPattern(void);
  21 static void TestBadPattern(void);
  22 static void TestFreezable(void);
  23 static void TestSpan(void);
  24
  25 void addUSetTest(TestNode** root);
  26
  27 static void expect(const USet* set,
  28                    const char* inList,
  29                    const char* outList,
  30                    UErrorCode* ec);
  31 static void expectContainment(const USet* set,
  32                               const char* list,
  33                               UBool isIn);
  34 static char oneUCharToChar(UChar32 c);
  35 static void expectItems(const USet* set,
  36                         const char* items);
  37
  38 void
  39 addUSetTest(TestNode** root) {
  40     TEST(TestAPI);
  41     TEST(Testj2269);
  42     TEST(TestSerialized);
  43     TEST(TestNonInvariantPattern);
  44     TEST(TestBadPattern);
  45     TEST(TestFreezable);
  46     TEST(TestSpan);
  47 }
  48
  49 /*------------------------------------------------------------------
  50  * Tests
  51  *------------------------------------------------------------------*/
  52
  53 static void Testj2269() {
  54   UErrorCode status = U_ZERO_ERROR;
  55   UChar a[4] = { 0x61, 0x62, 0x63, 0 };
  56   USet *s = uset_open(1, 0);
  57   uset_addString(s, a, 3);
  58   a[0] = 0x63; a[1] = 0x63;
  59   expect(s, "{abc}", "{ccc}", &status);
  60   uset_close(s);
  61 }
  62
  63 static const UChar PAT[] = {91,97,45,99,123,97,98,125,93,0}; /* "[a-c{ab}]" */
  64 static const int32_t PAT_LEN = (sizeof(PAT) / sizeof(PAT[0])) - 1;
  65
  66 static const UChar PAT_lb[] = {0x6C, 0x62, 0}; /* "lb" */
  67 static const int32_t PAT_lb_LEN = (sizeof(PAT_lb) / sizeof(PAT_lb[0])) - 1;
  68
  69 static const UChar VAL_SP[] = {0x53, 0x50, 0}; /* "SP" */
  70 static const int32_t VAL_SP_LEN = (sizeof(VAL_SP) / sizeof(VAL_SP[0])) - 1;
  71
  72 static const UChar STR_bc[] = {98,99,0}; /* "bc" */
  73 static const int32_t STR_bc_LEN = (sizeof(STR_bc) / sizeof(STR_bc[0])) - 1;
  74
  75 static const UChar STR_ab[] = {97,98,0}; /* "ab" */
  76 static const int32_t STR_ab_LEN = (sizeof(STR_ab) / sizeof(STR_ab[0])) - 1;
  77
  78 /**
  79  * Basic API test for uset.x
  80  */
  81 static void TestAPI() {
  82     USet* set;
  83     USet* set2;
  84     UErrorCode ec;
  85
  86     /* [] */
  87     set = uset_openEmpty();
  88     expect(set, "", "abc{ab}", NULL);
  89     uset_close(set);
  90
  91     set = uset_open(1, 0);
  92     expect(set, "", "abc{ab}", NULL);
  93     uset_close(set);
  94
  95     set = uset_open(1, 1);
  96     uset_clear(set);
  97     expect(set, "", "abc{ab}", NULL);
  98     uset_close(set);
  99
 100     /* [ABC] */
 101     set = uset_open(0x0041, 0x0043);
 102     expect(set, "ABC", "DEF{ab}", NULL);
 103     uset_close(set);
 104
 105     /* [a-c{ab}] */
 106     ec = U_ZERO_ERROR;
 107     set = uset_openPattern(PAT, PAT_LEN, &ec);
 108     if(U_FAILURE(ec)) {
 109         log_err("uset_openPattern([a-c{ab}]) failed - %s\n", u_errorName(ec));
 110         return;
 111     }
 112     if(!uset_resemblesPattern(PAT, PAT_LEN, 0)) {
 113         log_err("uset_resemblesPattern of PAT failed\n");
 114     }
 115     expect(set, "abc{ab}", "def{bc}", &ec);
 116
 117     /* [a-d{ab}] */
 118     uset_add(set, 0x64);
 119     expect(set, "abcd{ab}", "ef{bc}", NULL);
 120
 121     /* [acd{ab}{bc}] */
 122     uset_remove(set, 0x62);
 123     uset_addString(set, STR_bc, STR_bc_LEN);
 124     expect(set, "acd{ab}{bc}", "bef{cd}", NULL);
 125
 126     /* [acd{bc}] */
 127     uset_removeString(set, STR_ab, STR_ab_LEN);
 128     expect(set, "acd{bc}", "bfg{ab}", NULL);
 129
 130     /* [^acd{bc}] */
 131     uset_complement(set);
 132     expect(set, "bef{bc}", "acd{ac}", NULL);
 133
 134     /* [a-e{bc}] */
 135     uset_complement(set);
 136     uset_addRange(set, 0x0062, 0x0065);
 137     expect(set, "abcde{bc}", "fg{ab}", NULL);
 138
 139     /* [de{bc}] */
 140     uset_removeRange(set, 0x0050, 0x0063);
 141     expect(set, "de{bc}", "bcfg{ab}", NULL);
 142
 143     /* [g-l] */
 144     uset_set(set, 0x0067, 0x006C);
 145     expect(set, "ghijkl", "de{bc}", NULL);
 146
 147     if (uset_indexOf(set, 0x0067) != 0) {
 148         log_err("uset_indexOf failed finding correct index of 'g'\n");
 149     }
 150
 151     if (uset_charAt(set, 0) != 0x0067) {
 152         log_err("uset_charAt failed finding correct char 'g' at index 0\n");
 153     }
 154
 155     /* How to test this one...? */
 156     uset_compact(set);
 157
 158     /* [g-i] */
 159     uset_retain(set, 0x0067, 0x0069);
 160     expect(set, "ghi", "dejkl{bc}", NULL);
 161
 162     /* UCHAR_ASCII_HEX_DIGIT */
 163     uset_applyIntPropertyValue(set, UCHAR_ASCII_HEX_DIGIT, 1, &ec);
 164     if(U_FAILURE(ec)) {
 165         log_err("uset_applyIntPropertyValue([UCHAR_ASCII_HEX_DIGIT]) failed - %s\n", u_errorName(ec));
 166         return;
 167     }
 168     expect(set, "0123456789ABCDEFabcdef", "GHIjkl{bc}", NULL);
 169
 170     /* [ab] */
 171     uset_clear(set);
 172     uset_addAllCodePoints(set, STR_ab, STR_ab_LEN);
 173     expect(set, "ab", "def{ab}", NULL);
 174     if (uset_containsAllCodePoints(set, STR_bc, STR_bc_LEN)){
 175         log_err("set should not conatin all characters of \"bc\" \n");
 176     }
 177
 178     /* [] */
 179     set2 = uset_open(1, 1);
 180     uset_clear(set2);
 181
 182     /* space */
 183     uset_applyPropertyAlias(set2, PAT_lb, PAT_lb_LEN, VAL_SP, VAL_SP_LEN, &ec);
 184     expect(set2, " ", "abcdefghi{bc}", NULL);
 185
 186     /* [a-c] */
 187     uset_set(set2, 0x0061, 0x0063);
 188     /* [g-i] */
 189     uset_set(set, 0x0067, 0x0069);
 190
 191     /* [a-c g-i] */
 192     if (uset_containsSome(set, set2)) {
 193         log_err("set should not contain some of set2 yet\n");
 194     }
 195     uset_complementAll(set, set2);
 196     if (!uset_containsSome(set, set2)) {
 197         log_err("set should contain some of set2\n");
 198     }
 199     expect(set, "abcghi", "def{bc}", NULL);
 200
 201     /* [g-i] */
 202     uset_removeAll(set, set2);
 203     expect(set, "ghi", "abcdef{bc}", NULL);
 204
 205     /* [a-c g-i] */
 206     uset_addAll(set2, set);
 207     expect(set2, "abcghi", "def{bc}", NULL);
 208
 209     /* [g-i] */
 210     uset_retainAll(set2, set);
 211     expect(set2, "ghi", "abcdef{bc}", NULL);
 212
 213     uset_close(set);
 214     uset_close(set2);
 215 }
 216
 217 /*------------------------------------------------------------------
 218  * Support
 219  *------------------------------------------------------------------*/
 220
 221 /**
 222  * Verifies that the given set contains the characters and strings in
 223  * inList, and does not contain those in outList.  Also verifies that
 224  * 'set' is not NULL and that 'ec' succeeds.
 225  * @param set the set to test, or NULL (on error)
 226  * @param inList list of set contents, in iteration order.  Format is
 227  * list of individual strings, in iteration order, followed by sorted
 228  * list of strings, delimited by {}.  This means we do not test
 229  * characters '{' or '}' and we do not test strings containing those
 230  * characters either.
 231  * @param outList list of things not in the set.  Same format as
 232  * inList.
 233  * @param ec an error code, checked for success.  May be NULL in which
 234  * case it is ignored.
 235  */
 236 static void expect(const USet* set,
 237                    const char* inList,
 238                    const char* outList,
 239                    UErrorCode* ec) {
 240     if (ec!=NULL && U_FAILURE(*ec)) {
 241         log_err("FAIL: %s\n", u_errorName(*ec));
 242         return;
 243     }
 244     if (set == NULL) {
 245         log_err("FAIL: USet is NULL\n");
 246         return;
 247     }
 248     expectContainment(set, inList, TRUE);
 249     expectContainment(set, outList, FALSE);
 250     expectItems(set, inList);
 251 }
 252
 253 static void expectContainment(const USet* set,
 254                               const char* list,
 255                               UBool isIn) {
 256     const char* p = list;
 257     UChar ustr[4096];
 258     char *pat;
 259     UErrorCode ec;
 260     int32_t rangeStart = -1, rangeEnd = -1, length;
 261
 262     ec = U_ZERO_ERROR;
 263     length = uset_toPattern(set, ustr, sizeof(ustr), TRUE, &ec);
 264     if(U_FAILURE(ec)) {
 265         log_err("FAIL: uset_toPattern() fails in expectContainment() - %s\n", u_errorName(ec));
 266         return;
 267     }
 268     pat=aescstrdup(ustr, length);
 269
 270     while (*p) {
 271         if (*p=='{') {
 272             const char* stringStart = ++p;
 273             int32_t stringLength = 0;
 274             char strCopy[64];
 275
 276             while (*p++ != '}') {
 277             }
 278             stringLength = (int32_t)(p - stringStart - 1);
 279             strncpy(strCopy, stringStart, stringLength);
 280             strCopy[stringLength] = 0;
 281
 282             u_charsToUChars(stringStart, ustr, stringLength);
 283
 284             if (uset_containsString(set, ustr, stringLength) == isIn) {
 285                 log_verbose("Ok: %s %s \"%s\"\n", pat,
 286                             (isIn ? "contains" : "does not contain"),
 287                             strCopy);
 288             } else {
 289                 log_data_err("FAIL: %s %s \"%s\" (Are you missing data?)\n", pat,
 290                         (isIn ? "does not contain" : "contains"),
 291                         strCopy);
 292             }
 293         }
 294
 295         else {
 296             UChar32 c;
 297
 298             u_charsToUChars(p, ustr, 1);
 299             c = ustr[0];
 300
 301             if (uset_contains(set, c) == isIn) {
 302                 log_verbose("Ok: %s %s '%c'\n", pat,
 303                             (isIn ? "contains" : "does not contain"),
 304                             *p);
 305             } else {
 306                 log_data_err("FAIL: %s %s '%c' (Are you missing data?)\n", pat,
 307                         (isIn ? "does not contain" : "contains"),
 308                         *p);
 309             }
 310
 311             /* Test the range API too by looking for ranges */
 312             if (c == rangeEnd+1) {
 313                 rangeEnd = c;
 314             } else {
 315                 if (rangeStart >= 0) {
 316                     if (uset_containsRange(set, rangeStart, rangeEnd) == isIn) {
 317                         log_verbose("Ok: %s %s U+%04X-U+%04X\n", pat,
 318                                     (isIn ? "contains" : "does not contain"),
 319                                     rangeStart, rangeEnd);
 320                     } else {
 321                         log_data_err("FAIL: %s %s U+%04X-U+%04X (Are you missing data?)\n", pat,
 322                                 (isIn ? "does not contain" : "contains"),
 323                                 rangeStart, rangeEnd);
 324                     }
 325                 }
 326                 rangeStart = rangeEnd = c;
 327             }
 328
 329             ++p;
 330         }
 331     }
 332
 333     if (rangeStart >= 0) {
 334         if (uset_containsRange(set, rangeStart, rangeEnd) == isIn) {
 335             log_verbose("Ok: %s %s U+%04X-U+%04X\n", pat,
 336                         (isIn ? "contains" : "does not contain"),
 337                         rangeStart, rangeEnd);
 338         } else {
 339             log_data_err("FAIL: %s %s U+%04X-U+%04X (Are you missing data?)\n", pat,
 340                     (isIn ? "does not contain" : "contains"),
 341                     rangeStart, rangeEnd);
 342         }
 343     }
 344 }
 345
 346 /* This only works for invariant BMP chars */
 347 static char oneUCharToChar(UChar32 c) {
 348     UChar ubuf[1];
 349     char buf[1];
 350     ubuf[0] = (UChar) c;
 351     u_UCharsToChars(ubuf, buf, 1);
 352     return buf[0];
 353 }
 354
 355 static void expectItems(const USet* set,
 356                         const char* items) {
 357     const char* p = items;
 358     UChar ustr[4096], itemStr[4096];
 359     char buf[4096];
 360     char *pat;
 361     UErrorCode ec;
 362     int32_t expectedSize = 0;
 363     int32_t itemCount = uset_getItemCount(set);
 364     int32_t itemIndex = 0;
 365     UChar32 start = 1, end = 0;
 366     int32_t itemLen = 0, length;
 367
 368     ec = U_ZERO_ERROR;
 369     length = uset_toPattern(set, ustr, sizeof(ustr), TRUE, &ec);
 370     if (U_FAILURE(ec)) {
 371         log_err("FAIL: uset_toPattern => %s\n", u_errorName(ec));
 372         return;
 373     }
 374     pat=aescstrdup(ustr, length);
 375
 376     if (uset_isEmpty(set) != (strlen(items)==0)) {
 377         log_data_err("FAIL: %s should return %s from isEmpty (Are you missing data?)\n",
 378                 pat,
 379                 strlen(items)==0 ? "TRUE" : "FALSE");
 380     }
 381
 382     /* Don't test patterns starting with "[^" */
 383     if (u_strlen(ustr) > 2 && ustr[1] == 0x5e /*'^'*/) {
 384         return;
 385     }
 386
 387     while (*p) {
 388
 389         ++expectedSize;
 390
 391         if (start > end || start == -1) {
 392             /* Fetch our next item */
 393             if (itemIndex >= itemCount) {
 394                 log_data_err("FAIL: ran out of items iterating %s (Are you missing data?)\n", pat);
 395                 return;
 396             }
 397
 398             itemLen = uset_getItem(set, itemIndex, &start, &end,
 399                                    itemStr, sizeof(itemStr), &ec);
 400             if (U_FAILURE(ec) || itemLen < 0) {
 401                 log_err("FAIL: uset_getItem => %s\n", u_errorName(ec));
 402                 return;
 403             }
 404
 405             if (itemLen == 0) {
 406                 log_verbose("Ok: %s item %d is %c-%c\n", pat,
 407                             itemIndex, oneUCharToChar(start),
 408                             oneUCharToChar(end));
 409             } else {
 410                 itemStr[itemLen] = 0;
 411                 u_UCharsToChars(itemStr, buf, itemLen+1);
 412                 log_verbose("Ok: %s item %d is \"%s\"\n", pat, itemIndex, buf);
 413             }
 414
 415             ++itemIndex;
 416         }
 417
 418         if (*p=='{') {
 419             const char* stringStart = ++p;
 420             int32_t stringLength = 0;
 421             char strCopy[64];
 422
 423             while (*p++ != '}') {
 424             }
 425             stringLength = (int32_t)(p - stringStart - 1);
 426             strncpy(strCopy, stringStart, stringLength);
 427             strCopy[stringLength] = 0;
 428
 429             u_charsToUChars(stringStart, ustr, stringLength);
 430             ustr[stringLength] = 0;
 431
 432             if (itemLen == 0) {
 433                 log_err("FAIL: for %s expect \"%s\" next, but got a char\n",
 434                         pat, strCopy);
 435                 return;
 436             }
 437
 438             if (u_strcmp(ustr, itemStr) != 0) {
 439                 log_err("FAIL: for %s expect \"%s\" next\n",
 440                         pat, strCopy);
 441                 return;
 442             }
 443         }
 444
 445         else {
 446             UChar32 c;
 447
 448             u_charsToUChars(p, ustr, 1);
 449             c = ustr[0];
 450
 451             if (itemLen != 0) {
 452                 log_err("FAIL: for %s expect '%c' next, but got a string\n",
 453                         pat, *p);
 454                 return;
 455             }
 456
 457             if (c != start++) {
 458                 log_err("FAIL: for %s expect '%c' next\n",
 459                         pat, *p);
 460                 return;
 461             }
 462
 463             ++p;
 464         }
 465     }
 466
 467     if (uset_size(set) == expectedSize) {
 468         log_verbose("Ok: %s size is %d\n", pat, expectedSize);
 469     } else {
 470         log_err("FAIL: %s size is %d, expected %d\n",
 471                 pat, uset_size(set), expectedSize);
 472     }
 473 }
 474
 475 static void
 476 TestSerialized() {
 477     uint16_t buffer[1000];
 478     USerializedSet sset;
 479     USet *set;
 480     UErrorCode errorCode;
 481     UChar32 c;
 482     int32_t length;
 483
 484     /* use a pattern that generates both BMP and supplementary code points */
 485     U_STRING_DECL(pattern, "[:Cf:]", 6);
 486     U_STRING_INIT(pattern, "[:Cf:]", 6);
 487
 488     errorCode=U_ZERO_ERROR;
 489     set=uset_openPattern(pattern, -1, &errorCode);
 490     if(U_FAILURE(errorCode)) {
 491         log_data_err("uset_openPattern([:Cf:]) failed - %s (Are you missing data?)\n", u_errorName(errorCode));
 492         return;
 493     }
 494
 495     length=uset_serialize(set, buffer, LENGTHOF(buffer), &errorCode);
 496     if(U_FAILURE(errorCode)) {
 497         log_err("unable to uset_serialize([:Cf:]) - %s\n", u_errorName(errorCode));
 498         uset_close(set);
 499         return;
 500     }
 501
 502     uset_getSerializedSet(&sset, buffer, length);
 503     for(c=0; c<=0x10ffff; ++c) {
 504         if(uset_contains(set, c)!=uset_serializedContains(&sset, c)) {
 505             log_err("uset_contains(U+%04x)!=uset_serializedContains(U+%04x)\n", c);
 506             break;
 507         }
 508     }
 509
 510     uset_close(set);
 511 }
 512
 513 /**
 514  * Make sure that when non-invariant chars are passed to uset_openPattern
 515  * they do not cause an ugly failure mode (e.g. assertion failure).
 516  * JB#3795.
 517  */
 518 static void
 519 TestNonInvariantPattern() {
 520     UErrorCode ec = U_ZERO_ERROR;
 521     /* The critical part of this test is that the following pattern
 522        must contain a non-invariant character. */
 523     static const char *pattern = "[:ccc!=0:]";
 524     UChar buf[256];
 525     int32_t len = u_unescape(pattern, buf, 256);
 526     /* This test 'fails' by having an assertion failure within the
 527        following call.  It passes by running to completion with no
 528        assertion failure. */
 529     USet *set = uset_openPattern(buf, len, &ec);
 530     uset_close(set);
 531 }
 532
 533 static void TestBadPattern(void) {
 534     UErrorCode status = U_ZERO_ERROR;
 535     USet *pat;
 536     U_STRING_DECL(pattern, "[", 1);
 537     U_STRING_INIT(pattern, "[", 1);
 538     pat = uset_openPatternOptions(pattern, u_strlen(pattern), 0, &status);
 539     if (pat != NULL || U_SUCCESS(status)) {
 540         log_err("uset_openPatternOptions did not fail as expected %s\n", u_errorName(status));
 541     }
 542 }
 543
 544 static USet *openIDSet() {
 545     UErrorCode errorCode = U_ZERO_ERROR;
 546     U_STRING_DECL(pattern, "[:ID_Continue:]", 15);
 547     U_STRING_INIT(pattern, "[:ID_Continue:]", 15);
 548     return uset_openPattern(pattern, 15, &errorCode);
 549 }
 550
 551 static void TestFreezable() {
 552     USet *idSet;
 553     USet *frozen;
 554     USet *thawed;
 555
 556     idSet=openIDSet();
 557
 558     if (idSet == NULL) {
 559         log_data_err("openIDSet() returned NULL. (Are you missing data?)\n");
 560         uset_close(idSet);
 561         return;
 562     }
 563
 564     frozen=uset_clone(idSet);
 565
 566     if (frozen == NULL) {
 567         log_err("uset_Clone() returned NULL\n");
 568         return;
 569     }
 570
 571     if(!uset_equals(frozen, idSet)) {
 572         log_err("uset_clone() did not make an equal copy\n");
 573     }
 574
 575     uset_freeze(frozen);
 576     uset_addRange(frozen, 0xd802, 0xd805);
 577
 578     if(uset_isFrozen(idSet) || !uset_isFrozen(frozen) || !uset_equals(frozen, idSet)) {
 579         log_err("uset_freeze() or uset_isFrozen() does not work\n");
 580     }
 581
 582     thawed=uset_cloneAsThawed(frozen);
 583
 584     if (thawed == NULL) {
 585         log_err("uset_cloneAsThawed(frozen) returned NULL");
 586         uset_close(frozen);
 587         uset_close(idSet);
 588         return;
 589     }
 590
 591     uset_addRange(thawed, 0xd802, 0xd805);
 592
 593     if(uset_isFrozen(thawed) || uset_equals(thawed, idSet) || !uset_containsRange(thawed, 0xd802, 0xd805)) {
 594         log_err("uset_cloneAsThawed() does not work\n");
 595     }
 596
 597     uset_close(idSet);
 598     uset_close(frozen);
 599     uset_close(thawed);
 600 }
 601
 602 static void TestSpan() {
 603     static const UChar s16[2]={ 0xe01, 0x3000 };
 604     static const char* s8="\xE0\xB8\x81\xE3\x80\x80";
 605
 606     USet *idSet=openIDSet();
 607
 608     if (idSet == NULL) {
 609         log_data_err("openIDSet() returned NULL (Are you missing data?)\n");
 610         return;
 611     }
 612
 613     if(
 614         1!=uset_span(idSet, s16, 2, USET_SPAN_CONTAINED) ||
 615         0!=uset_span(idSet, s16, 2, USET_SPAN_NOT_CONTAINED) ||
 616         2!=uset_spanBack(idSet, s16, 2, USET_SPAN_CONTAINED) ||
 617         1!=uset_spanBack(idSet, s16, 2, USET_SPAN_NOT_CONTAINED)
 618     ) {
 619         log_err("uset_span() or uset_spanBack() does not work\n");
 620     }
 621
 622     if(
 623         3!=uset_spanUTF8(idSet, s8, 6, USET_SPAN_CONTAINED) ||
 624         0!=uset_spanUTF8(idSet, s8, 6, USET_SPAN_NOT_CONTAINED) ||
 625         6!=uset_spanBackUTF8(idSet, s8, 6, USET_SPAN_CONTAINED) ||
 626         3!=uset_spanBackUTF8(idSet, s8, 6, USET_SPAN_NOT_CONTAINED)
 627     ) {
 628         log_err("uset_spanUTF8() or uset_spanBackUTF8() does not work\n");
 629     }
 630
 631     uset_freeze(idSet);
 632
 633     if(
 634         1!=uset_span(idSet, s16, 2, USET_SPAN_CONTAINED) ||
 635         0!=uset_span(idSet, s16, 2, USET_SPAN_NOT_CONTAINED) ||
 636         2!=uset_spanBack(idSet, s16, 2, USET_SPAN_CONTAINED) ||
 637         1!=uset_spanBack(idSet, s16, 2, USET_SPAN_NOT_CONTAINED)
 638     ) {
 639         log_err("uset_span(frozen) or uset_spanBack(frozen) does not work\n");
 640     }
 641
 642     if(
 643         3!=uset_spanUTF8(idSet, s8, 6, USET_SPAN_CONTAINED) ||
 644         0!=uset_spanUTF8(idSet, s8, 6, USET_SPAN_NOT_CONTAINED) ||
 645         6!=uset_spanBackUTF8(idSet, s8, 6, USET_SPAN_CONTAINED) ||
 646         3!=uset_spanBackUTF8(idSet, s8, 6, USET_SPAN_NOT_CONTAINED)
 647     ) {
 648         log_err("uset_spanUTF8(frozen) or uset_spanBackUTF8(frozen) does not work\n");
 649     }
 650
 651     uset_close(idSet);
 652 }
 653
 654 /*eof*/