icuSources/test/intltest/itercoll.cpp

   1 // © 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-2016, International Business Machines Corporation and
   6  * others. All Rights Reserved.
   7  ********************************************************************/
   8
   9 #include "unicode/utypes.h"
  10
  11 #if !UCONFIG_NO_COLLATION
  12
  13 #include "unicode/coll.h"
  14 #include "unicode/tblcoll.h"
  15 #include "unicode/unistr.h"
  16 #include "unicode/sortkey.h"
  17 #include "itercoll.h"
  18 #include "unicode/schriter.h"
  19 #include "unicode/chariter.h"
  20 #include "unicode/uchar.h"
  21 #include "cmemory.h"
  22
  23 static UErrorCode status = U_ZERO_ERROR;
  24
  25 CollationIteratorTest::CollationIteratorTest()
  26  : test1("What subset of all possible test cases?", ""),
  27    test2("has the highest probability of detecting", "")
  28 {
  29     en_us = (RuleBasedCollator *)Collator::createInstance(Locale::getUS(), status);
  30     if(U_FAILURE(status)) {
  31       delete en_us;
  32       en_us = 0;
  33       errcheckln(status, "Collator creation failed with %s", u_errorName(status));
  34       return;
  35     }
  36
  37 }
  38
  39 CollationIteratorTest::~CollationIteratorTest()
  40 {
  41     delete en_us;
  42 }
  43
  44 /**
  45  * Test for CollationElementIterator previous and next for the whole set of
  46  * unicode characters.
  47  */
  48 void CollationIteratorTest::TestUnicodeChar()
  49 {
  50     CollationElementIterator *iter;
  51     UChar codepoint;
  52     UnicodeString source;
  53
  54     for (codepoint = 1; codepoint < 0xFFFE;)
  55     {
  56       source.remove();
  57
  58       while (codepoint % 0xFF != 0)
  59       {
  60         if (u_isdefined(codepoint))
  61           source += codepoint;
  62         codepoint ++;
  63       }
  64
  65       if (u_isdefined(codepoint))
  66         source += codepoint;
  67
  68       if (codepoint != 0xFFFF)
  69         codepoint ++;
  70
  71       iter = en_us->createCollationElementIterator(source);
  72       /* A basic test to see if it's working at all */
  73       backAndForth(*iter);
  74       delete iter;
  75     }
  76 }
  77
  78 /**
  79  * Test for CollationElementIterator.previous()
  80  *
  81  * @bug 4108758 - Make sure it works with contracting characters
  82  *
  83  */
  84 void CollationIteratorTest::TestPrevious(/* char* par */)
  85 {
  86     UErrorCode status = U_ZERO_ERROR;
  87     CollationElementIterator *iter = en_us->createCollationElementIterator(test1);
  88
  89     // A basic test to see if it's working at all
  90     backAndForth(*iter);
  91     delete iter;
  92
  93     // Test with a contracting character sequence
  94     UnicodeString source;
  95     RuleBasedCollator *c1 = NULL;
  96     c1 = new RuleBasedCollator(
  97         (UnicodeString)"&a,A < b,B < c,C, d,D < z,Z < ch,cH,Ch,CH", status);
  98
  99     if (c1 == NULL || U_FAILURE(status))
 100     {
 101         errln("Couldn't create a RuleBasedCollator with a contracting sequence.");
 102         delete c1;
 103         return;
 104     }
 105
 106     source = "abchdcba";
 107     iter = c1->createCollationElementIterator(source);
 108     backAndForth(*iter);
 109     delete iter;
 110     delete c1;
 111
 112     // Test with an expanding character sequence
 113     RuleBasedCollator *c2 = NULL;
 114     c2 = new RuleBasedCollator((UnicodeString)"&a < b < c/abd < d", status);
 115
 116     if (c2 == NULL || U_FAILURE(status))
 117     {
 118         errln("Couldn't create a RuleBasedCollator with an expanding sequence.");
 119         delete c2;
 120         return;
 121     }
 122
 123     source = "abcd";
 124     iter = c2->createCollationElementIterator(source);
 125     backAndForth(*iter);
 126     delete iter;
 127     delete c2;
 128
 129     // Now try both
 130     RuleBasedCollator *c3 = NULL;
 131     c3 = new RuleBasedCollator((UnicodeString)"&a < b < c/aba < d < z < ch", status);
 132
 133     if (c3 == NULL || U_FAILURE(status))
 134     {
 135         errln("Couldn't create a RuleBasedCollator with both an expanding and a contracting sequence.");
 136         delete c3;
 137         return;
 138     }
 139
 140     source = "abcdbchdc";
 141     iter = c3->createCollationElementIterator(source);
 142     backAndForth(*iter);
 143     delete iter;
 144     delete c3;
 145
 146     status=U_ZERO_ERROR;
 147     source= CharsToUnicodeString("\\u0e41\\u0e02\\u0e41\\u0e02\\u0e27abc");
 148
 149     Collator *c4 = Collator::createInstance(Locale("th", "TH", ""), status);
 150     if(U_FAILURE(status)){
 151         errln("Couldn't create a collator");
 152     }
 153     iter = ((RuleBasedCollator*)c4)->createCollationElementIterator(source);
 154     backAndForth(*iter);
 155     delete iter;
 156     delete c4;
 157
 158     source= CharsToUnicodeString("\\u0061\\u30CF\\u3099\\u30FC");
 159     Collator *c5 = Collator::createInstance(Locale("ja", "JP", ""), status);
 160
 161     iter = ((RuleBasedCollator*)c5)->createCollationElementIterator(source);
 162     if(U_FAILURE(status)){
 163         errln("Couldn't create Japanese collator\n");
 164     }
 165     backAndForth(*iter);
 166     delete iter;
 167     delete c5;
 168 }
 169
 170 /**
 171  * Test for getOffset() and setOffset()
 172  */
 173 void CollationIteratorTest::TestOffset(/* char* par */)
 174 {
 175     CollationElementIterator *iter = en_us->createCollationElementIterator(test1);
 176     UErrorCode status = U_ZERO_ERROR;
 177     // testing boundaries
 178     iter->setOffset(0, status);
 179     if (U_FAILURE(status) || iter->previous(status) != CollationElementIterator::NULLORDER) {
 180         errln("Error: After setting offset to 0, we should be at the end "
 181                 "of the backwards iteration");
 182     }
 183     iter->setOffset(test1.length(), status);
 184     if (U_FAILURE(status) || iter->next(status) != CollationElementIterator::NULLORDER) {
 185         errln("Error: After setting offset to end of the string, we should "
 186                 "be at the end of the backwards iteration");
 187     }
 188
 189     // Run all the way through the iterator, then get the offset
 190     int32_t orderLength = 0;
 191     Order *orders = getOrders(*iter, orderLength);
 192
 193     int32_t offset = iter->getOffset();
 194
 195     if (offset != test1.length())
 196     {
 197         UnicodeString msg1("offset at end != length: ");
 198         UnicodeString msg2(" vs ");
 199
 200         errln(msg1 + offset + msg2 + test1.length());
 201     }
 202
 203     // Now set the offset back to the beginning and see if it works
 204     CollationElementIterator *pristine = en_us->createCollationElementIterator(test1);
 205
 206     iter->setOffset(0, status);
 207
 208     if (U_FAILURE(status))
 209     {
 210         errln("setOffset failed.");
 211     }
 212     else
 213     {
 214         assertEqual(*iter, *pristine);
 215     }
 216
 217     delete pristine;
 218     delete[] orders;
 219     delete iter;
 220
 221     // setting offset in the middle of a contraction
 222     UnicodeString contraction = "change";
 223     status = U_ZERO_ERROR;
 224     RuleBasedCollator tailored("& a < ch", status);
 225     if (U_FAILURE(status)) {
 226         errln("Error: in creation of Spanish collator - %s", u_errorName(status));
 227         return;
 228     }
 229     iter = tailored.createCollationElementIterator(contraction);
 230     Order *order = getOrders(*iter, orderLength);
 231     iter->setOffset(1, status); // sets offset in the middle of ch
 232     int32_t order2Length = 0;
 233     Order *order2 = getOrders(*iter, order2Length);
 234     if (orderLength != order2Length || uprv_memcmp(order, order2, orderLength * sizeof(Order)) != 0) {
 235         errln("Error: setting offset in the middle of a contraction should be the same as setting it to the start of the contraction");
 236     }
 237     delete[] order;
 238     delete[] order2;
 239     delete iter;
 240     contraction = "peache";
 241     iter = tailored.createCollationElementIterator(contraction);
 242     iter->setOffset(3, status);
 243     order = getOrders(*iter, orderLength);
 244     iter->setOffset(4, status); // sets offset in the middle of ch
 245     order2 = getOrders(*iter, order2Length);
 246     if (orderLength != order2Length || uprv_memcmp(order, order2, orderLength * sizeof(Order)) != 0) {
 247         errln("Error: setting offset in the middle of a contraction should be the same as setting it to the start of the contraction");
 248     }
 249     delete[] order;
 250     delete[] order2;
 251     delete iter;
 252     // setting offset in the middle of a surrogate pair
 253     UnicodeString surrogate = UNICODE_STRING_SIMPLE("\\ud800\\udc00str").unescape();
 254     iter = tailored.createCollationElementIterator(surrogate);
 255     order = getOrders(*iter, orderLength);
 256     iter->setOffset(1, status); // sets offset in the middle of surrogate
 257     order2 = getOrders(*iter, order2Length);
 258     if (orderLength != order2Length || uprv_memcmp(order, order2, orderLength * sizeof(Order)) != 0) {
 259         errln("Error: setting offset in the middle of a surrogate pair should be the same as setting it to the start of the surrogate pair");
 260     }
 261     delete[] order;
 262     delete[] order2;
 263     delete iter;
 264     surrogate = UNICODE_STRING_SIMPLE("simple\\ud800\\udc00str").unescape();
 265     iter = tailored.createCollationElementIterator(surrogate);
 266     iter->setOffset(6, status);
 267     order = getOrders(*iter, orderLength);
 268     iter->setOffset(7, status); // sets offset in the middle of surrogate
 269     order2 = getOrders(*iter, order2Length);
 270     if (orderLength != order2Length || uprv_memcmp(order, order2, orderLength * sizeof(Order)) != 0) {
 271         errln("Error: setting offset in the middle of a surrogate pair should be the same as setting it to the start of the surrogate pair");
 272     }
 273     delete[] order;
 274     delete[] order2;
 275     delete iter;
 276     // TODO: try iterating halfway through a messy string.
 277 }
 278
 279 /**
 280  * Test for setText()
 281  */
 282 void CollationIteratorTest::TestSetText(/* char* par */)
 283 {
 284     CollationElementIterator *iter1 = en_us->createCollationElementIterator(test1);
 285     CollationElementIterator *iter2 = en_us->createCollationElementIterator(test2);
 286     UErrorCode status = U_ZERO_ERROR;
 287
 288     // Run through the second iterator just to exercise it
 289     int32_t c = iter2->next(status);
 290     int32_t i = 0;
 291
 292     while ( ++i < 10 && c != CollationElementIterator::NULLORDER)
 293     {
 294         if (U_FAILURE(status))
 295         {
 296             errln("iter2->next() returned an error.");
 297             delete iter2;
 298             delete iter1;
 299         }
 300
 301         c = iter2->next(status);
 302     }
 303
 304     // Now set it to point to the same string as the first iterator
 305     iter2->setText(test1, status);
 306
 307     if (U_FAILURE(status))
 308     {
 309         errln("call to iter2->setText(test1) failed.");
 310     }
 311     else
 312     {
 313         assertEqual(*iter1, *iter2);
 314     }
 315     iter1->reset();
 316     //now use the overloaded setText(ChracterIterator&, UErrorCode) function to set the text
 317     CharacterIterator* chariter = new StringCharacterIterator(test1);
 318     iter2->setText(*chariter, status);
 319     if (U_FAILURE(status))
 320     {
 321         errln("call to iter2->setText(chariter(test1)) failed.");
 322     }
 323     else
 324     {
 325         assertEqual(*iter1, *iter2);
 326     }
 327
 328     // test for an empty string
 329     UnicodeString empty("");
 330     iter1->setText(empty, status);
 331     if (U_FAILURE(status)
 332         || iter1->next(status) != (int32_t)CollationElementIterator::NULLORDER) {
 333         errln("Empty string should have no CEs.");
 334     }
 335     ((StringCharacterIterator *)chariter)->setText(empty);
 336     iter1->setText(*chariter, status);
 337     if (U_FAILURE(status)
 338         || iter1->next(status) != (int32_t)CollationElementIterator::NULLORDER) {
 339         errln("Empty string should have no CEs.");
 340     }
 341     delete chariter;
 342     delete iter2;
 343     delete iter1;
 344 }
 345
 346 /** @bug 4108762
 347  * Test for getMaxExpansion()
 348  */
 349 void CollationIteratorTest::TestMaxExpansion(/* char* par */)
 350 {
 351     UErrorCode          status = U_ZERO_ERROR;
 352     UnicodeString rule("&a < ab < c/aba < d < z < ch");
 353     RuleBasedCollator  *coll   = new RuleBasedCollator(rule, status);
 354     UChar               ch     = 0;
 355     UnicodeString       str(ch);
 356
 357     CollationElementIterator *iter   = coll->createCollationElementIterator(str);
 358
 359     while (ch < 0xFFFF && U_SUCCESS(status)) {
 360         int      count = 1;
 361         uint32_t order;
 362         ch ++;
 363         UnicodeString str(ch);
 364         iter->setText(str, status);
 365         order = iter->previous(status);
 366
 367         /* thai management */
 368         if (CollationElementIterator::isIgnorable(order))
 369             order = iter->previous(status);
 370
 371         while (U_SUCCESS(status)
 372             && iter->previous(status) != (int32_t)CollationElementIterator::NULLORDER)
 373         {
 374             count ++;
 375         }
 376
 377         if (U_FAILURE(status) && iter->getMaxExpansion(order) < count) {
 378             errln("Failure at codepoint %d, maximum expansion count < %d\n",
 379                 ch, count);
 380         }
 381     }
 382
 383     delete iter;
 384     delete coll;
 385 }
 386
 387 /*
 388  * @bug 4157299
 389  */
 390 void CollationIteratorTest::TestClearBuffers(/* char* par */)
 391 {
 392     UErrorCode status = U_ZERO_ERROR;
 393     RuleBasedCollator *c = new RuleBasedCollator((UnicodeString)"&a < b < c & ab = d", status);
 394
 395     if (c == NULL || U_FAILURE(status))
 396     {
 397         errln("Couldn't create a RuleBasedCollator.");
 398         delete c;
 399         return;
 400     }
 401
 402     UnicodeString source("abcd");
 403     CollationElementIterator *i = c->createCollationElementIterator(source);
 404     int32_t e0 = i->next(status);    // save the first collation element
 405
 406     if (U_FAILURE(status))
 407     {
 408         errln("call to i->next() failed. err=%s", u_errorName(status));
 409     }
 410     else
 411     {
 412         i->setOffset(3, status);        // go to the expanding character
 413
 414         if (U_FAILURE(status))
 415         {
 416             errln("call to i->setOffset(3) failed. err=%s", u_errorName(status));
 417         }
 418         else
 419         {
 420             i->next(status);                // but only use up half of it
 421
 422             if (U_FAILURE(status))
 423             {
 424                 errln("call to i->next() failed. err=%s", u_errorName(status));
 425             }
 426             else
 427             {
 428                 i->setOffset(0, status);        // go back to the beginning
 429
 430                 if (U_FAILURE(status))
 431                 {
 432                     errln("call to i->setOffset(0) failed. err=%s", u_errorName(status));
 433                 }
 434                 else
 435                 {
 436                     int32_t e = i->next(status);    // and get this one again
 437
 438                     if (U_FAILURE(status))
 439                     {
 440                         errln("call to i->next() failed. err=%s", u_errorName(status));
 441                     }
 442                     else if (e != e0)
 443                     {
 444                         errln("got 0x%X, expected 0x%X", e, e0);
 445                     }
 446                 }
 447             }
 448         }
 449     }
 450
 451     delete i;
 452     delete c;
 453 }
 454
 455 /**
 456  * Testing the assignment operator
 457  */
 458 void CollationIteratorTest::TestAssignment()
 459 {
 460     UErrorCode status = U_ZERO_ERROR;
 461     RuleBasedCollator *coll =
 462         (RuleBasedCollator *)Collator::createInstance(status);
 463
 464     if (coll == NULL || U_FAILURE(status))
 465     {
 466         errln("Couldn't create a default collator.");
 467         return;
 468     }
 469
 470     UnicodeString source("abcd");
 471     CollationElementIterator *iter1 =
 472         coll->createCollationElementIterator(source);
 473
 474     CollationElementIterator iter2 = *iter1;
 475
 476     if (*iter1 != iter2) {
 477         errln("Fail collation iterator assignment does not produce the same elements");
 478     }
 479
 480     CollationElementIterator iter3(*iter1);
 481
 482     if (*iter1 != iter3) {
 483         errln("Fail collation iterator copy constructor does not produce the same elements");
 484     }
 485
 486     source = CharsToUnicodeString("a\\u0300\\u0325");
 487     coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
 488     CollationElementIterator *iter4
 489                         = coll->createCollationElementIterator(source);
 490     CollationElementIterator iter5(*iter4);
 491     if (*iter4 != iter5) {
 492         errln("collation iterator assignment does not produce the same elements");
 493     }
 494     iter4->next(status);
 495     if (U_FAILURE(status) || *iter4 == iter5) {
 496         errln("collation iterator not equal");
 497     }
 498     iter5.next(status);
 499     if (U_FAILURE(status) || *iter4 != iter5) {
 500         errln("collation iterator equal");
 501     }
 502     iter4->next(status);
 503     if (U_FAILURE(status) || *iter4 == iter5) {
 504         errln("collation iterator not equal");
 505     }
 506     iter5.next(status);
 507     if (U_FAILURE(status) || *iter4 != iter5) {
 508         errln("collation iterator equal");
 509     }
 510     CollationElementIterator iter6(*iter4);
 511     if (*iter4 != iter6) {
 512         errln("collation iterator equal");
 513     }
 514     iter4->next(status);
 515     if (U_FAILURE(status) || *iter4 == iter5) {
 516         errln("collation iterator not equal");
 517     }
 518     iter5.next(status);
 519     if (U_FAILURE(status) || *iter4 != iter5) {
 520         errln("collation iterator equal");
 521     }
 522     iter4->next(status);
 523     if (U_FAILURE(status) || *iter4 == iter5) {
 524         errln("collation iterator not equal");
 525     }
 526     iter5.next(status);
 527     if (U_FAILURE(status) || *iter4 != iter5) {
 528         errln("collation iterator equal");
 529     }
 530     delete iter1;
 531     delete iter4;
 532     delete coll;
 533 }
 534
 535 /**
 536  * Testing the constructors
 537  */
 538 void CollationIteratorTest::TestConstructors()
 539 {
 540     UErrorCode status = U_ZERO_ERROR;
 541     RuleBasedCollator *coll =
 542         (RuleBasedCollator *)Collator::createInstance(status);
 543     if (coll == NULL || U_FAILURE(status))
 544     {
 545         errln("Couldn't create a default collator.");
 546         return;
 547     }
 548
 549     // testing protected constructor with character iterator as argument
 550     StringCharacterIterator chariter(test1);
 551     CollationElementIterator *iter1 =
 552         coll->createCollationElementIterator(chariter);
 553     if (U_FAILURE(status)) {
 554         errln("Couldn't create collation element iterator with character iterator.");
 555         return;
 556     }
 557     CollationElementIterator *iter2 =
 558         coll->createCollationElementIterator(test1);
 559
 560     // initially the 2 collation element iterators should be the same
 561     if (*iter1 != *iter1 || *iter2 != *iter2 || *iter1 != *iter2
 562         || *iter2 != *iter1) {
 563         errln("CollationElementIterators constructed with the same string data should be the same at the start");
 564     }
 565     assertEqual(*iter1, *iter2);
 566
 567     delete iter1;
 568     delete iter2;
 569
 570     // tests empty strings
 571     UnicodeString empty("");
 572     iter1 = coll->createCollationElementIterator(empty);
 573     chariter.setText(empty);
 574     iter2 = coll->createCollationElementIterator(chariter);
 575     if (*iter1 != *iter1 || *iter2 != *iter2 || *iter1 != *iter2
 576         || *iter2 != *iter1) {
 577         errln("CollationElementIterators constructed with the same string data should be the same at the start");
 578     }
 579     if (iter1->next(status) != (int32_t)CollationElementIterator::NULLORDER) {
 580         errln("Empty string should have no CEs.");
 581     }
 582     if (iter2->next(status) != (int32_t)CollationElementIterator::NULLORDER) {
 583         errln("Empty string should have no CEs.");
 584     }
 585     delete iter1;
 586     delete iter2;
 587     delete coll;
 588 }
 589
 590 /**
 591  * Testing the strength order
 592  */
 593 void CollationIteratorTest::TestStrengthOrder()
 594 {
 595     int order = 0x0123ABCD;
 596
 597     UErrorCode status = U_ZERO_ERROR;
 598     RuleBasedCollator *coll =
 599         (RuleBasedCollator *)Collator::createInstance(status);
 600     if (coll == NULL || U_FAILURE(status))
 601     {
 602         errln("Couldn't create a default collator.");
 603         return;
 604     }
 605
 606     coll->setStrength(Collator::PRIMARY);
 607     CollationElementIterator *iter =
 608         coll->createCollationElementIterator(test1);
 609
 610     if (iter == NULL) {
 611         errln("Couldn't create a collation element iterator from default collator");
 612         return;
 613     }
 614
 615     if (iter->strengthOrder(order) != 0x01230000) {
 616         errln("Strength order for a primary strength collator should be the first 2 bytes");
 617         return;
 618     }
 619
 620     coll->setStrength(Collator::SECONDARY);
 621     if (iter->strengthOrder(order) != 0x0123AB00) {
 622         errln("Strength order for a secondary strength collator should be the third byte");
 623         return;
 624     }
 625
 626     coll->setStrength(Collator::TERTIARY);
 627     if (iter->strengthOrder(order) != order) {
 628         errln("Strength order for a tertiary strength collator should be the third byte");
 629         return;
 630     }
 631     delete iter;
 632     delete coll;
 633 }
 634
 635 /**
 636  * Return a string containing all of the collation orders
 637  * returned by calls to next on the specified iterator
 638  */
 639 UnicodeString &CollationIteratorTest::orderString(CollationElementIterator &iter, UnicodeString &target)
 640 {
 641     int32_t order;
 642     UErrorCode status = U_ZERO_ERROR;
 643
 644     while ((order = iter.next(status)) != CollationElementIterator::NULLORDER)
 645     {
 646         target += "0x";
 647         appendHex(order, 8, target);
 648         target += " ";
 649     }
 650
 651     return target;
 652 }
 653
 654 void CollationIteratorTest::assertEqual(CollationElementIterator &i1, CollationElementIterator &i2)
 655 {
 656     int32_t c1, c2, count = 0;
 657     UErrorCode status = U_ZERO_ERROR;
 658
 659     do
 660     {
 661         c1 = i1.next(status);
 662         c2 = i2.next(status);
 663
 664         if (c1 != c2)
 665         {
 666             errln("    %d: strength(0x%X) != strength(0x%X)", count, c1, c2);
 667             break;
 668         }
 669
 670         count += 1;
 671     }
 672     while (c1 != CollationElementIterator::NULLORDER);
 673 }
 674
 675 void CollationIteratorTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/)
 676 {
 677     if (exec)
 678     {
 679         logln("Collation Iteration Tests: ");
 680     }
 681
 682     if(en_us) {
 683       switch (index)
 684       {
 685           case  0: name = "TestPrevious";      if (exec) TestPrevious(/* par */);     break;
 686           case  1: name = "TestOffset";        if (exec) TestOffset(/* par */);       break;
 687           case  2: name = "TestSetText";       if (exec) TestSetText(/* par */);      break;
 688           case  3: name = "TestMaxExpansion";  if (exec) TestMaxExpansion(/* par */); break;
 689           case  4: name = "TestClearBuffers";  if (exec) TestClearBuffers(/* par */); break;
 690           case  5: name = "TestUnicodeChar";   if (exec) TestUnicodeChar(/* par */);  break;
 691           case  6: name = "TestAssignment";    if (exec) TestAssignment(/* par */);    break;
 692           case  7: name = "TestConstructors";  if (exec) TestConstructors(/* par */); break;
 693           case  8: name = "TestStrengthOrder"; if (exec) TestStrengthOrder(/* par */); break;
 694           default: name = ""; break;
 695       }
 696     } else {
 697       dataerrln("Class iterator not instantiated");
 698       name = "";
 699     }
 700 }
 701
 702 #endif /* #if !UCONFIG_NO_COLLATION */