icuSources/test/intltest/citrtest.cpp

   1 /****************************************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 1997-2012, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  * Modification History:
   6  *
   7  *   Date          Name        Description
   8  *   05/22/2000    Madhu       Added tests for testing new API for utf16 support and more
   9  ****************************************************************************************/
  10
  11 #include <string.h>
  12 #include "utypeinfo.h"  // for 'typeid' to work
  13
  14 #include "unicode/chariter.h"
  15 #include "unicode/ustring.h"
  16 #include "unicode/unistr.h"
  17 #include "unicode/schriter.h"
  18 #include "unicode/uchriter.h"
  19 #include "unicode/uiter.h"
  20 #include "unicode/putil.h"
  21 #include "unicode/utf16.h"
  22 #include "citrtest.h"
  23
  24
  25 class  SCharacterIterator : public CharacterIterator {
  26 public:
  27     SCharacterIterator(const UnicodeString& textStr){
  28         text = textStr;
  29         pos=0;
  30         textLength = textStr.length();
  31         begin = 0;
  32         end=textLength;
  33
  34     }
  35
  36     virtual ~SCharacterIterator(){};
  37
  38
  39     void setText(const UnicodeString& newText){
  40         text = newText;
  41     }
  42
  43     virtual void getText(UnicodeString& result) {
  44         text.extract(0,text.length(),result);
  45     }
  46     static UClassID getStaticClassID(void){
  47         return (UClassID)(&fgClassID);
  48     }
  49     virtual UClassID getDynamicClassID(void) const{
  50         return getStaticClassID();
  51     }
  52
  53     virtual UBool operator==(const ForwardCharacterIterator& /*that*/) const{
  54         return TRUE;
  55     }
  56
  57     virtual CharacterIterator* clone(void) const {
  58         return NULL;
  59     }
  60     virtual int32_t hashCode(void) const{
  61         return DONE;
  62     }
  63     virtual UChar nextPostInc(void){ return text.charAt(pos++);}
  64     virtual UChar32 next32PostInc(void){return text.char32At(pos++);}
  65     virtual UBool hasNext() { return TRUE;};
  66     virtual UChar first(){return DONE;};
  67     virtual UChar32 first32(){return DONE;};
  68     virtual UChar last(){return DONE;};
  69     virtual UChar32 last32(){return DONE;};
  70     virtual UChar setIndex(int32_t /*pos*/){return DONE;};
  71     virtual UChar32 setIndex32(int32_t /*pos*/){return DONE;};
  72     virtual UChar current() const{return DONE;};
  73     virtual UChar32 current32() const{return DONE;};
  74     virtual UChar next(){return DONE;};
  75     virtual UChar32 next32(){return DONE;};
  76     virtual UChar previous(){return DONE;};
  77     virtual UChar32 previous32(){return DONE;};
  78     virtual int32_t move(int32_t delta,CharacterIterator::EOrigin origin){
  79         switch(origin) {
  80         case kStart:
  81             pos = begin + delta;
  82             break;
  83         case kCurrent:
  84             pos += delta;
  85             break;
  86         case kEnd:
  87             pos = end + delta;
  88             break;
  89         default:
  90             break;
  91         }
  92
  93         if(pos < begin) {
  94             pos = begin;
  95         } else if(pos > end) {
  96             pos = end;
  97         }
  98
  99         return pos;
 100     };
 101     virtual int32_t move32(int32_t delta, CharacterIterator::EOrigin origin){
 102         switch(origin) {
 103         case kStart:
 104             pos = begin;
 105             if(delta > 0) {
 106                 U16_FWD_N(text, pos, end, delta);
 107             }
 108             break;
 109         case kCurrent:
 110             if(delta > 0) {
 111                 U16_FWD_N(text, pos, end, delta);
 112             } else {
 113                 U16_BACK_N(text, begin, pos, -delta);
 114             }
 115             break;
 116         case kEnd:
 117             pos = end;
 118             if(delta < 0) {
 119                 U16_BACK_N(text, begin, pos, -delta);
 120             }
 121             break;
 122         default:
 123             break;
 124         }
 125
 126         return pos;
 127     };
 128     virtual UBool hasPrevious() {return TRUE;};
 129
 130   SCharacterIterator&  operator=(const SCharacterIterator&    that){
 131      text = that.text;
 132      return *this;
 133   }
 134
 135
 136 private:
 137     UnicodeString text;
 138     static const char fgClassID;
 139 };
 140 const char SCharacterIterator::fgClassID=0;
 141
 142 #define LENGTHOF(array) ((int32_t)(sizeof(array)/sizeof((array)[0])))
 143
 144 CharIterTest::CharIterTest()
 145 {
 146 }
 147 void CharIterTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
 148 {
 149     if (exec) logln("TestSuite CharIterTest: ");
 150     switch (index) {
 151         case 0: name = "TestConstructionAndEquality"; if (exec) TestConstructionAndEquality(); break;
 152         case 1: name = "TestConstructionAndEqualityUChariter"; if (exec) TestConstructionAndEqualityUChariter(); break;
 153         case 2: name = "TestIteration"; if (exec) TestIteration(); break;
 154         case 3: name = "TestIterationUChar32"; if (exec) TestIterationUChar32(); break;
 155         case 4: name = "TestUCharIterator"; if (exec) TestUCharIterator(); break;
 156         case 5: name = "TestCoverage"; if(exec) TestCoverage(); break;
 157         case 6: name = "TestCharIteratorSubClasses"; if (exec) TestCharIteratorSubClasses(); break;
 158         default: name = ""; break; //needed to end loop
 159     }
 160 }
 161
 162 void CharIterTest::TestCoverage(){
 163     UnicodeString  testText("Now is the time for all good men to come to the aid of their country.");
 164     UnicodeString testText2("\\ud800\\udc01deadbeef");
 165     testText2 = testText2.unescape();
 166     SCharacterIterator* test = new SCharacterIterator(testText);
 167     if(test->firstPostInc()!= 0x004E){
 168         errln("Failed: firstPostInc() failed");
 169     }
 170     if(test->getIndex()!=1){
 171         errln("Failed: getIndex().");
 172     }
 173     if(test->getLength()!=testText.length()){
 174         errln("Failed: getLength()");
 175     }
 176     test->setToStart();
 177     if(test->getIndex()!=0){
 178         errln("Failed: setToStart().");
 179     }
 180     test->setToEnd();
 181     if(test->getIndex()!=testText.length()){
 182         errln("Failed: setToEnd().");
 183     }
 184     if(test->startIndex() != 0){
 185         errln("Failed: startIndex()");
 186     }
 187     test->setText(testText2);
 188     if(test->first32PostInc()!= testText2.char32At(0)){
 189         errln("Failed: first32PostInc() failed");
 190     }
 191
 192     delete test;
 193
 194 }
 195 void CharIterTest::TestConstructionAndEquality() {
 196     UnicodeString  testText("Now is the time for all good men to come to the aid of their country.");
 197     UnicodeString  testText2("Don't bother using this string.");
 198     UnicodeString result1, result2, result3;
 199
 200     CharacterIterator* test1 = new StringCharacterIterator(testText);
 201     CharacterIterator* test1b= new StringCharacterIterator(testText, -1);
 202     CharacterIterator* test1c= new StringCharacterIterator(testText, 100);
 203     CharacterIterator* test1d= new StringCharacterIterator(testText, -2, 100, 5);
 204     CharacterIterator* test1e= new StringCharacterIterator(testText, 100, 20, 5);
 205     CharacterIterator* test2 = new StringCharacterIterator(testText, 5);
 206     CharacterIterator* test3 = new StringCharacterIterator(testText, 2, 20, 5);
 207     CharacterIterator* test4 = new StringCharacterIterator(testText2);
 208     CharacterIterator* test5 = test1->clone();
 209
 210     if (test1d->startIndex() < 0)
 211         errln("Construction failed: startIndex is negative");
 212     if (test1d->endIndex() > testText.length())
 213         errln("Construction failed: endIndex is greater than the text length");
 214     if (test1d->getIndex() < test1d->startIndex() || test1d->endIndex() < test1d->getIndex())
 215         errln("Construction failed: index is invalid");
 216
 217     if (*test1 == *test2 || *test1 == *test3 || *test1 == *test4)
 218         errln("Construction or operator== failed: Unequal objects compared equal");
 219     if (*test1 != *test5)
 220         errln("clone() or equals() failed: Two clones tested unequal");
 221
 222     if (test1->hashCode() == test2->hashCode() || test1->hashCode() == test3->hashCode()
 223                     || test1->hashCode() == test4->hashCode())
 224         errln("hashCode() failed:  different objects have same hash code");
 225
 226     if (test1->hashCode() != test5->hashCode())
 227         errln("hashCode() failed:  identical objects have different hash codes");
 228
 229     if(test1->getLength() != testText.length()){
 230         errln("getLength of CharacterIterator failed");
 231     }
 232     test1->getText(result1);
 233     test1b->getText(result2);
 234     test1c->getText(result3);
 235     if(result1 != result2 ||  result1 != result3)
 236         errln("construction failed or getText() failed");
 237
 238
 239     test1->setIndex(5);
 240     if (*test1 != *test2 || *test1 == *test5)
 241         errln("setIndex() failed");
 242
 243     *((StringCharacterIterator*)test1) = *((StringCharacterIterator*)test3);
 244     if (*test1 != *test3 || *test1 == *test5)
 245         errln("operator= failed");
 246
 247     delete test2;
 248     delete test3;
 249     delete test4;
 250     delete test5;
 251     delete test1b;
 252     delete test1c;
 253     delete test1d;
 254     delete test1e;
 255
 256
 257     StringCharacterIterator* testChar1=new StringCharacterIterator(testText);
 258     StringCharacterIterator* testChar2=new StringCharacterIterator(testText2);
 259     StringCharacterIterator* testChar3=(StringCharacterIterator*)test1->clone();
 260
 261     testChar1->getText(result1);
 262     testChar2->getText(result2);
 263     testChar3->getText(result3);
 264     if(result1 != result3 || result1 == result2)
 265         errln("getText() failed");
 266     testChar3->setText(testText2);
 267     testChar3->getText(result3);
 268     if(result1 == result3 || result2 != result3)
 269         errln("setText() or getText() failed");
 270     testChar3->setText(testText);
 271     testChar3->getText(result3);
 272     if(result1 != result3 || result1 == result2)
 273         errln("setText() or getText() round-trip failed");
 274
 275     delete testChar1;
 276     delete testChar2;
 277     delete testChar3;
 278     delete test1;
 279
 280 }
 281 void CharIterTest::TestConstructionAndEqualityUChariter() {
 282     U_STRING_DECL(testText, "Now is the time for all good men to come to the aid of their country.", 69);
 283     U_STRING_DECL(testText2, "Don't bother using this string.", 31);
 284
 285     U_STRING_INIT(testText, "Now is the time for all good men to come to the aid of their country.", 69);
 286     U_STRING_INIT(testText2, "Don't bother using this string.", 31);
 287
 288     UnicodeString result, result4, result5;
 289
 290     UCharCharacterIterator* test1 = new UCharCharacterIterator(testText, u_strlen(testText));
 291     UCharCharacterIterator* test2 = new UCharCharacterIterator(testText, u_strlen(testText), 5);
 292     UCharCharacterIterator* test3 = new UCharCharacterIterator(testText, u_strlen(testText), 2, 20, 5);
 293     UCharCharacterIterator* test4 = new UCharCharacterIterator(testText2, u_strlen(testText2));
 294     UCharCharacterIterator* test5 = (UCharCharacterIterator*)test1->clone();
 295     UCharCharacterIterator* test6 = new UCharCharacterIterator(*test1);
 296
 297     // j785: length=-1 will use u_strlen()
 298     UCharCharacterIterator* test7a = new UCharCharacterIterator(testText, -1);
 299     UCharCharacterIterator* test7b = new UCharCharacterIterator(testText, -1);
 300     UCharCharacterIterator* test7c = new UCharCharacterIterator(testText, -1, 2, 20, 5);
 301
 302     // Bad parameters.
 303     UCharCharacterIterator* test8a = new UCharCharacterIterator(testText, -1, -1, 20, 5);
 304     UCharCharacterIterator* test8b = new UCharCharacterIterator(testText, -1, 2, 100, 5);
 305     UCharCharacterIterator* test8c = new UCharCharacterIterator(testText, -1, 2, 20, 100);
 306
 307     if (test8a->startIndex() < 0)
 308         errln("Construction failed: startIndex is negative");
 309     if (test8b->endIndex() != u_strlen(testText))
 310         errln("Construction failed: endIndex is different from the text length");
 311     if (test8c->getIndex() < test8c->startIndex() || test8c->endIndex() < test8c->getIndex())
 312         errln("Construction failed: index is invalid");
 313
 314     if (*test1 == *test2 || *test1 == *test3 || *test1 == *test4 )
 315         errln("Construction or operator== failed: Unequal objects compared equal");
 316     if (*test1 != *test5 )
 317         errln("clone() or equals() failed: Two clones tested unequal");
 318
 319     if (*test6 != *test1 )
 320         errln("copy construction or equals() failed: Two copies tested unequal");
 321
 322     if (test1->hashCode() == test2->hashCode() || test1->hashCode() == test3->hashCode()
 323                     || test1->hashCode() == test4->hashCode())
 324         errln("hashCode() failed:  different objects have same hash code");
 325
 326     if (test1->hashCode() != test5->hashCode())
 327         errln("hashCode() failed:  identical objects have different hash codes");
 328
 329     test7a->getText(result);
 330     test7b->getText(result4);
 331     test7c->getText(result5);
 332
 333     if(result != UnicodeString(testText) || result4 != result || result5 != result)
 334         errln("error in construction");
 335
 336     test1->getText(result);
 337     test4->getText(result4);
 338     test5->getText(result5);
 339     if(result != result5 || result == result4)
 340         errln("getText() failed");
 341     test5->setText(testText2, u_strlen(testText2));
 342     test5->getText(result5);
 343     if(result == result5 || result4 != result5)
 344         errln("setText() or getText() failed");
 345     test5->setText(testText, u_strlen(testText));
 346     test5->getText(result5);
 347     if(result != result5 || result == result4)
 348         errln("setText() or getText() round-trip failed");
 349
 350
 351     test1->setIndex(5);
 352     if (*test1 != *test2 || *test1 == *test5)
 353         errln("setIndex() failed");
 354     test8b->setIndex32(5);
 355     if (test8b->getIndex()!=5)
 356         errln("setIndex32() failed");
 357
 358     *test1 = *test3;
 359     if (*test1 != *test3 || *test1 == *test5)
 360         errln("operator= failed");
 361
 362     delete test1;
 363     delete test2;
 364     delete test3;
 365     delete test4;
 366     delete test5;
 367     delete test6;
 368     delete test7a;
 369     delete test7b;
 370     delete test7c;
 371     delete test8a;
 372     delete test8b;
 373     delete test8c;
 374 }
 375
 376
 377 void CharIterTest::TestIteration() {
 378     UnicodeString text("Now is the time for all good men to come to the aid of their country.");
 379
 380     UChar c;
 381     int32_t i;
 382     {
 383         StringCharacterIterator   iter(text, 5);
 384
 385         UnicodeString iterText;
 386         iter.getText(iterText);
 387         if (iterText != text)
 388           errln("iter.getText() failed");
 389
 390         if (iter.current() != text[(int32_t)5])
 391             errln("Iterator didn't start out in the right place.");
 392
 393         c = iter.first();
 394         i = 0;
 395
 396         if (iter.startIndex() != 0 || iter.endIndex() != text.length())
 397             errln("startIndex() or endIndex() failed");
 398
 399         logln("Testing forward iteration...");
 400         do {
 401             if (c == CharacterIterator::DONE && i != text.length())
 402                 errln("Iterator reached end prematurely");
 403             else if (c != text[i])
 404                 errln((UnicodeString)"Character mismatch at position " + i +
 405                                     ", iterator has " + UCharToUnicodeString(c) +
 406                                     ", string has " + UCharToUnicodeString(text[i]));
 407
 408             if (iter.current() != c)
 409                 errln("current() isn't working right");
 410             if (iter.getIndex() != i)
 411                 errln("getIndex() isn't working right");
 412
 413             if (c != CharacterIterator::DONE) {
 414                 c = iter.next();
 415                 i++;
 416             }
 417         } while (c != CharacterIterator::DONE);
 418         c=iter.next();
 419         if(c!= CharacterIterator::DONE)
 420             errln("next() didn't return DONE at the end");
 421         c=iter.setIndex(text.length()+1);
 422         if(c!= CharacterIterator::DONE)
 423             errln("setIndex(len+1) didn't return DONE");
 424
 425         c = iter.last();
 426         i = text.length() - 1;
 427
 428         logln("Testing backward iteration...");
 429         do {
 430             if (c == CharacterIterator::DONE && i >= 0)
 431                 errln("Iterator reached end prematurely");
 432             else if (c != text[i])
 433                 errln((UnicodeString)"Character mismatch at position " + i +
 434                                     ", iterator has " + UCharToUnicodeString(c) +
 435                                     ", string has " + UCharToUnicodeString(text[i]));
 436
 437             if (iter.current() != c)
 438                 errln("current() isn't working right");
 439             if (iter.getIndex() != i)
 440                 errln("getIndex() isn't working right");
 441             if(iter.setIndex(i) != c)
 442                 errln("setIndex() isn't working right");
 443
 444             if (c != CharacterIterator::DONE) {
 445                 c = iter.previous();
 446                 i--;
 447             }
 448         } while (c != CharacterIterator::DONE);
 449
 450         c=iter.previous();
 451         if(c!= CharacterIterator::DONE)
 452             errln("previous didn't return DONE at the beginning");
 453
 454
 455         //testing firstPostInc, nextPostInc, setTostart
 456         i = 0;
 457         c=iter.firstPostInc();
 458         if(c != text[i])
 459             errln((UnicodeString)"firstPostInc failed.  Expected->" +
 460                          UCharToUnicodeString(text[i]) + " Got->" + UCharToUnicodeString(c));
 461         if(iter.getIndex() != i+1)
 462             errln((UnicodeString)"getIndex() after firstPostInc() failed");
 463
 464         iter.setToStart();
 465         i=0;
 466         if (iter.startIndex() != 0)
 467             errln("setToStart failed");
 468
 469         logln("Testing forward iteration...");
 470         do {
 471             if (c != CharacterIterator::DONE)
 472                 c = iter.nextPostInc();
 473
 474             if(c != text[i])
 475                 errln((UnicodeString)"Character mismatch at position " + i +
 476                                     (UnicodeString)", iterator has " + UCharToUnicodeString(c) +
 477                                     (UnicodeString)", string has " + UCharToUnicodeString(text[i]));
 478
 479             i++;
 480             if(iter.getIndex() != i)
 481                 errln("getIndex() aftr nextPostInc() isn't working right");
 482             if(iter.current() != text[i])
 483                 errln("current() after nextPostInc() isn't working right");
 484         } while (iter.hasNext());
 485         c=iter.nextPostInc();
 486         if(c!= CharacterIterator::DONE)
 487             errln("nextPostInc() didn't return DONE at the beginning");
 488     }
 489
 490     {
 491         StringCharacterIterator iter(text, 5, 15, 10);
 492         if (iter.startIndex() != 5 || iter.endIndex() != 15)
 493             errln("creation of a restricted-range iterator failed");
 494
 495         if (iter.getIndex() != 10 || iter.current() != text[(int32_t)10])
 496             errln("starting the iterator in the middle didn't work");
 497
 498         c = iter.first();
 499         i = 5;
 500
 501         logln("Testing forward iteration over a range...");
 502         do {
 503             if (c == CharacterIterator::DONE && i != 15)
 504                 errln("Iterator reached end prematurely");
 505             else if (c != text[i])
 506                 errln((UnicodeString)"Character mismatch at position " + i +
 507                                     ", iterator has " + UCharToUnicodeString(c) +
 508                                     ", string has " + UCharToUnicodeString(text[i]));
 509
 510             if (iter.current() != c)
 511                 errln("current() isn't working right");
 512             if (iter.getIndex() != i)
 513                 errln("getIndex() isn't working right");
 514             if(iter.setIndex(i) != c)
 515                 errln("setIndex() isn't working right");
 516
 517             if (c != CharacterIterator::DONE) {
 518                 c = iter.next();
 519                 i++;
 520             }
 521         } while (c != CharacterIterator::DONE);
 522
 523         c = iter.last();
 524         i = 14;
 525
 526         logln("Testing backward iteration over a range...");
 527         do {
 528             if (c == CharacterIterator::DONE && i >= 5)
 529                 errln("Iterator reached end prematurely");
 530             else if (c != text[i])
 531                 errln((UnicodeString)"Character mismatch at position " + i +
 532                                     ", iterator has " + UCharToUnicodeString(c) +
 533                                     ", string has " + UCharToUnicodeString(text[i]));
 534
 535             if (iter.current() != c)
 536                 errln("current() isn't working right");
 537             if (iter.getIndex() != i)
 538                 errln("getIndex() isn't working right");
 539
 540             if (c != CharacterIterator::DONE) {
 541                 c = iter.previous();
 542                 i--;
 543             }
 544         } while (c != CharacterIterator::DONE);
 545
 546
 547     }
 548 }
 549
 550 //Tests for new API for utf-16 support
 551 void CharIterTest::TestIterationUChar32() {
 552     UChar textChars[]={ 0x0061, 0x0062, 0xd841, 0xdc02, 0x20ac, 0xd7ff, 0xd842, 0xdc06, 0xd801, 0xdc00, 0x0061, 0x0000};
 553     UnicodeString text(textChars);
 554     UChar32 c;
 555     int32_t i;
 556     {
 557         StringCharacterIterator   iter(text, 1);
 558
 559         UnicodeString iterText;
 560         iter.getText(iterText);
 561         if (iterText != text)
 562           errln("iter.getText() failed");
 563
 564         if (iter.current32() != text[(int32_t)1])
 565             errln("Iterator didn't start out in the right place.");
 566
 567         c=iter.setToStart();
 568         i=0;
 569         i=iter.move32(1, CharacterIterator::kStart);
 570         c=iter.current32();
 571         if(c != text.char32At(1) || i!=1)
 572             errln("move32(1, kStart) didn't work correctly expected %X got %X", c, text.char32At(1) );
 573
 574         i=iter.move32(2, CharacterIterator::kCurrent);
 575         c=iter.current32();
 576         if(c != text.char32At(4) || i!=4)
 577             errln("move32(2, kCurrent) didn't work correctly expected %X got %X i=%ld", c, text.char32At(4), i);
 578
 579         i=iter.move32(-2, CharacterIterator::kCurrent);
 580         c=iter.current32();
 581         if(c != text.char32At(1) || i!=1)
 582             errln("move32(-2, kCurrent) didn't work correctly expected %X got %X i=%d", c, text.char32At(1), i);
 583
 584
 585         i=iter.move32(-2, CharacterIterator::kEnd);
 586         c=iter.current32();
 587         if(c != text.char32At((text.length()-3)) || i!=(text.length()-3))
 588             errln("move32(-2, kEnd) didn't work correctly expected %X got %X i=%d", c, text.char32At((text.length()-3)), i);
 589
 590
 591         c = iter.first32();
 592         i = 0;
 593
 594         if (iter.startIndex() != 0 || iter.endIndex() != text.length())
 595             errln("startIndex() or endIndex() failed");
 596
 597         logln("Testing forward iteration...");
 598         do {
 599             /* logln("c=%d i=%d char32At=%d", c, i, text.char32At(i)); */
 600             if (c == CharacterIterator::DONE && i != text.length())
 601                 errln("Iterator reached end prematurely");
 602             else if(iter.hasNext() == FALSE && i != text.length())
 603                 errln("Iterator reached end prematurely.  Failed at hasNext");
 604             else if (c != text.char32At(i))
 605                 errln("Character mismatch at position %d, iterator has %X, string has %X", i, c, text.char32At(i));
 606
 607             if (iter.current32() != c)
 608                 errln("current32() isn't working right");
 609             if(iter.setIndex32(i) != c)
 610                 errln("setIndex32() isn't working right");
 611             if (c != CharacterIterator::DONE) {
 612                 c = iter.next32();
 613                 i=UTF16_NEED_MULTIPLE_UCHAR(c) ? i+2 : i+1;
 614             }
 615         } while (c != CharacterIterator::DONE);
 616         if(iter.hasNext() == TRUE)
 617            errln("hasNext() returned true at the end of the string");
 618
 619
 620
 621         c=iter.setToEnd();
 622         if(iter.getIndex() != text.length() || iter.hasNext() != FALSE)
 623             errln("setToEnd failed");
 624
 625         c=iter.next32();
 626         if(c!= CharacterIterator::DONE)
 627             errln("next32 didn't return DONE at the end");
 628         c=iter.setIndex32(text.length()+1);
 629         if(c!= CharacterIterator::DONE)
 630             errln("setIndex32(len+1) didn't return DONE");
 631
 632
 633         c = iter.last32();
 634         i = text.length()-1;
 635         logln("Testing backward iteration...");
 636         do {
 637             if (c == CharacterIterator::DONE && i >= 0)
 638                 errln((UnicodeString)"Iterator reached start prematurely for i=" + i);
 639             else if(iter.hasPrevious() == FALSE && i>0)
 640                 errln((UnicodeString)"Iterator reached start prematurely for i=" + i);
 641             else if (c != text.char32At(i))
 642                 errln("Character mismatch at position %d, iterator has %X, string has %X", i, c, text.char32At(i));
 643
 644             if (iter.current32() != c)
 645                 errln("current32() isn't working right");
 646             if(iter.setIndex32(i) != c)
 647                 errln("setIndex32() isn't working right");
 648             if (iter.getIndex() != i)
 649                 errln("getIndex() isn't working right");
 650             if (c != CharacterIterator::DONE) {
 651                 c = iter.previous32();
 652                 i=UTF16_NEED_MULTIPLE_UCHAR(c) ? i-2 : i-1;
 653             }
 654         } while (c != CharacterIterator::DONE);
 655         if(iter.hasPrevious() == TRUE)
 656             errln("hasPrevious returned true after reaching the start");
 657
 658         c=iter.previous32();
 659         if(c!= CharacterIterator::DONE)
 660             errln("previous32 didn't return DONE at the beginning");
 661
 662
 663
 664
 665         //testing first32PostInc, next32PostInc, setTostart
 666         i = 0;
 667         c=iter.first32PostInc();
 668         if(c != text.char32At(i))
 669             errln("first32PostInc failed.  Expected->%X Got->%X", text.char32At(i), c);
 670         if(iter.getIndex() != U16_LENGTH(c) + i)
 671             errln((UnicodeString)"getIndex() after first32PostInc() failed");
 672
 673         iter.setToStart();
 674         i=0;
 675         if (iter.startIndex() != 0)
 676             errln("setToStart failed");
 677
 678         logln("Testing forward iteration...");
 679         do {
 680             if (c != CharacterIterator::DONE)
 681                 c = iter.next32PostInc();
 682
 683             if(c != text.char32At(i))
 684                 errln("Character mismatch at position %d, iterator has %X, string has %X", i, c, text.char32At(i));
 685
 686             i=UTF16_NEED_MULTIPLE_UCHAR(c) ? i+2 : i+1;
 687             if(iter.getIndex() != i)
 688                 errln("getIndex() aftr next32PostInc() isn't working right");
 689             if(iter.current32() != text.char32At(i))
 690                 errln("current() after next32PostInc() isn't working right");
 691         } while (iter.hasNext());
 692         c=iter.next32PostInc();
 693         if(c!= CharacterIterator::DONE)
 694             errln("next32PostInc() didn't return DONE at the beginning");
 695
 696
 697     }
 698
 699     {
 700         StringCharacterIterator iter(text, 1, 11, 10);
 701         if (iter.startIndex() != 1 || iter.endIndex() != 11)
 702             errln("creation of a restricted-range iterator failed");
 703
 704         if (iter.getIndex() != 10 || iter.current32() != text.char32At(10))
 705             errln("starting the iterator in the middle didn't work");
 706
 707         c = iter.first32();
 708
 709         i = 1;
 710
 711         logln("Testing forward iteration over a range...");
 712         do {
 713             if (c == CharacterIterator::DONE && i != 11)
 714                 errln("Iterator reached end prematurely");
 715             else if(iter.hasNext() == FALSE)
 716                 errln("Iterator reached end prematurely");
 717             else if (c != text.char32At(i))
 718                 errln("Character mismatch at position %d, iterator has %X, string has %X", i, c, text.char32At(i));
 719
 720             if (iter.current32() != c)
 721                 errln("current32() isn't working right");
 722             if(iter.setIndex32(i) != c)
 723                 errln("setIndex32() isn't working right");
 724
 725             if (c != CharacterIterator::DONE) {
 726                 c = iter.next32();
 727                 i=UTF16_NEED_MULTIPLE_UCHAR(c) ? i+2 : i+1;
 728             }
 729         } while (c != CharacterIterator::DONE);
 730         c=iter.next32();
 731         if(c != CharacterIterator::DONE)
 732             errln("error in next32()");
 733
 734
 735
 736         c=iter.last32();
 737         i = 10;
 738         logln("Testing backward iteration over a range...");
 739         do {
 740             if (c == CharacterIterator::DONE && i >= 5)
 741                 errln("Iterator reached start prematurely");
 742             else if(iter.hasPrevious() == FALSE && i > 5)
 743                 errln("Iterator reached start prematurely");
 744             else if (c != text.char32At(i))
 745                 errln("Character mismatch at position %d, iterator has %X, string has %X", i, c, text.char32At(i));
 746             if (iter.current32() != c)
 747                 errln("current32() isn't working right");
 748             if (iter.getIndex() != i)
 749                 errln("getIndex() isn't working right");
 750             if(iter.setIndex32(i) != c)
 751                 errln("setIndex32() isn't working right");
 752
 753             if (c != CharacterIterator::DONE) {
 754                 c = iter.previous32();
 755                 i=UTF16_NEED_MULTIPLE_UCHAR(c) ? i-2 : i-1;
 756             }
 757
 758         } while (c != CharacterIterator::DONE);
 759         c=iter.previous32();
 760         if(c!= CharacterIterator::DONE)
 761             errln("error on previous32");
 762
 763
 764     }
 765 }
 766
 767 void CharIterTest::TestUCharIterator(UCharIterator *iter, CharacterIterator &ci,
 768                                      const char *moves, const char *which) {
 769     int32_t m;
 770     UChar32 c, c2;
 771     UBool h, h2;
 772
 773     for(m=0;; ++m) {
 774         // move both iter and s[index]
 775         switch(moves[m]) {
 776         case '0':
 777             h=iter->hasNext(iter);
 778             h2=ci.hasNext();
 779             c=iter->current(iter);
 780             c2=ci.current();
 781             break;
 782         case '|':
 783             h=iter->hasNext(iter);
 784             h2=ci.hasNext();
 785             c=uiter_current32(iter);
 786             c2=ci.current32();
 787             break;
 788
 789         case '+':
 790             h=iter->hasNext(iter);
 791             h2=ci.hasNext();
 792             c=iter->next(iter);
 793             c2=ci.nextPostInc();
 794             break;
 795         case '>':
 796             h=iter->hasNext(iter);
 797             h2=ci.hasNext();
 798             c=uiter_next32(iter);
 799             c2=ci.next32PostInc();
 800             break;
 801
 802         case '-':
 803             h=iter->hasPrevious(iter);
 804             h2=ci.hasPrevious();
 805             c=iter->previous(iter);
 806             c2=ci.previous();
 807             break;
 808         case '<':
 809             h=iter->hasPrevious(iter);
 810             h2=ci.hasPrevious();
 811             c=uiter_previous32(iter);
 812             c2=ci.previous32();
 813             break;
 814
 815         case '2':
 816             h=h2=FALSE;
 817             c=(UChar32)iter->move(iter, 2, UITER_CURRENT);
 818             c2=(UChar32)ci.move(2, CharacterIterator::kCurrent);
 819             break;
 820
 821         case '8':
 822             h=h2=FALSE;
 823             c=(UChar32)iter->move(iter, -2, UITER_CURRENT);
 824             c2=(UChar32)ci.move(-2, CharacterIterator::kCurrent);
 825             break;
 826
 827         case 0:
 828             return;
 829         default:
 830             errln("error: unexpected move character '%c' in \"%s\"", moves[m], moves);
 831             return;
 832         }
 833
 834         // compare results
 835         if(c2==0xffff) {
 836             c2=(UChar32)-1;
 837         }
 838         if(c!=c2 || h!=h2 || ci.getIndex()!=iter->getIndex(iter, UITER_CURRENT)) {
 839             errln("error: UCharIterator(%s) misbehaving at \"%s\"[%d]='%c'", which, moves, m, moves[m]);
 840         }
 841     }
 842 }
 843
 844 void CharIterTest::TestUCharIterator() {
 845     // test string of length 8
 846     UnicodeString s=UnicodeString("a \\U00010001b\\U0010fffdz", "").unescape();
 847     const char *const moves=
 848         "0+++++++++" // 10 moves per line
 849         "----0-----"
 850         ">>|>>>>>>>"
 851         "<<|<<<<<<<"
 852         "22+>8>-8+2";
 853
 854     StringCharacterIterator sci(s), compareCI(s);
 855
 856     UCharIterator sIter, cIter, rIter;
 857
 858     uiter_setString(&sIter, s.getBuffer(), s.length());
 859     uiter_setCharacterIterator(&cIter, &sci);
 860     uiter_setReplaceable(&rIter, &s);
 861
 862     TestUCharIterator(&sIter, compareCI, moves, "uiter_setString");
 863     compareCI.setIndex(0);
 864     TestUCharIterator(&cIter, compareCI, moves, "uiter_setCharacterIterator");
 865     compareCI.setIndex(0);
 866     TestUCharIterator(&rIter, compareCI, moves, "uiter_setReplaceable");
 867
 868     // test move & getIndex some more
 869     sIter.start=2;
 870     sIter.index=3;
 871     sIter.limit=5;
 872     if( sIter.getIndex(&sIter, UITER_ZERO)!=0 ||
 873         sIter.getIndex(&sIter, UITER_START)!=2 ||
 874         sIter.getIndex(&sIter, UITER_CURRENT)!=3 ||
 875         sIter.getIndex(&sIter, UITER_LIMIT)!=5 ||
 876         sIter.getIndex(&sIter, UITER_LENGTH)!=s.length()
 877     ) {
 878         errln("error: UCharIterator(string).getIndex returns wrong index");
 879     }
 880
 881     if( sIter.move(&sIter, 4, UITER_ZERO)!=4 ||
 882         sIter.move(&sIter, 1, UITER_START)!=3 ||
 883         sIter.move(&sIter, 3, UITER_CURRENT)!=5 ||
 884         sIter.move(&sIter, -1, UITER_LIMIT)!=4 ||
 885         sIter.move(&sIter, -5, UITER_LENGTH)!=3 ||
 886         sIter.move(&sIter, 0, UITER_CURRENT)!=sIter.getIndex(&sIter, UITER_CURRENT) ||
 887         sIter.getIndex(&sIter, UITER_CURRENT)!=3
 888     ) {
 889         errln("error: UCharIterator(string).move sets/returns wrong index");
 890     }
 891
 892     sci=StringCharacterIterator(s, 2, 5, 3);
 893     uiter_setCharacterIterator(&cIter, &sci);
 894     if( cIter.getIndex(&cIter, UITER_ZERO)!=0 ||
 895         cIter.getIndex(&cIter, UITER_START)!=2 ||
 896         cIter.getIndex(&cIter, UITER_CURRENT)!=3 ||
 897         cIter.getIndex(&cIter, UITER_LIMIT)!=5 ||
 898         cIter.getIndex(&cIter, UITER_LENGTH)!=s.length()
 899     ) {
 900         errln("error: UCharIterator(character iterator).getIndex returns wrong index");
 901     }
 902
 903     if( cIter.move(&cIter, 4, UITER_ZERO)!=4 ||
 904         cIter.move(&cIter, 1, UITER_START)!=3 ||
 905         cIter.move(&cIter, 3, UITER_CURRENT)!=5 ||
 906         cIter.move(&cIter, -1, UITER_LIMIT)!=4 ||
 907         cIter.move(&cIter, -5, UITER_LENGTH)!=3 ||
 908         cIter.move(&cIter, 0, UITER_CURRENT)!=cIter.getIndex(&cIter, UITER_CURRENT) ||
 909         cIter.getIndex(&cIter, UITER_CURRENT)!=3
 910     ) {
 911         errln("error: UCharIterator(character iterator).move sets/returns wrong index");
 912     }
 913
 914
 915     if(cIter.getIndex(&cIter, (enum UCharIteratorOrigin)-1) != -1)
 916     {
 917         errln("error: UCharIterator(char iter).getIndex did not return error value");
 918     }
 919
 920     if(cIter.move(&cIter, 0, (enum UCharIteratorOrigin)-1) != -1)
 921     {
 922         errln("error: UCharIterator(char iter).move did not return error value");
 923     }
 924
 925
 926     if(rIter.getIndex(&rIter, (enum UCharIteratorOrigin)-1) != -1)
 927     {
 928         errln("error: UCharIterator(repl iter).getIndex did not return error value");
 929     }
 930
 931     if(rIter.move(&rIter, 0, (enum UCharIteratorOrigin)-1) != -1)
 932     {
 933         errln("error: UCharIterator(repl iter).move did not return error value");
 934     }
 935
 936
 937     if(sIter.getIndex(&sIter, (enum UCharIteratorOrigin)-1) != -1)
 938     {
 939         errln("error: UCharIterator(string iter).getIndex did not return error value");
 940     }
 941
 942     if(sIter.move(&sIter, 0, (enum UCharIteratorOrigin)-1) != -1)
 943     {
 944         errln("error: UCharIterator(string iter).move did not return error value");
 945     }
 946
 947     /* Testing function coverage on bad input */
 948     UErrorCode status = U_ZERO_ERROR;
 949     uiter_setString(&sIter, NULL, 1);
 950     uiter_setState(&sIter, 1, &status);
 951     if (status != U_UNSUPPORTED_ERROR) {
 952         errln("error: uiter_setState returned %s instead of U_UNSUPPORTED_ERROR", u_errorName(status));
 953     }
 954     status = U_ZERO_ERROR;
 955     uiter_setState(NULL, 1, &status);
 956     if (status != U_ILLEGAL_ARGUMENT_ERROR) {
 957         errln("error: uiter_setState returned %s instead of U_ILLEGAL_ARGUMENT_ERROR", u_errorName(status));
 958     }
 959     if (uiter_getState(&sIter) != UITER_NO_STATE) {
 960         errln("error: uiter_getState did not return UITER_NO_STATE on bad input");
 961     }
 962 }
 963
 964 // subclass test, and completing API coverage -------------------------------
 965
 966 class SubCharIter : public CharacterIterator {
 967 public:
 968     // public default constructor, to get coverage of CharacterIterator()
 969     SubCharIter() : CharacterIterator() {
 970         textLength=end=LENGTHOF(s);
 971         s[0]=0x61;      // 'a'
 972         s[1]=0xd900;    // U+50400
 973         s[2]=0xdd00;
 974         s[3]=0x2029;    // PS
 975     }
 976
 977     // useful stuff, mostly dummy but testing coverage and subclassability
 978     virtual UChar nextPostInc() {
 979         if(pos<LENGTHOF(s)) {
 980             return s[pos++];
 981         } else {
 982             return DONE;
 983         }
 984     }
 985
 986     virtual UChar32 next32PostInc() {
 987         if(pos<LENGTHOF(s)) {
 988             UChar32 c;
 989             U16_NEXT(s, pos, LENGTHOF(s), c);
 990             return c;
 991         } else {
 992             return DONE;
 993         }
 994     }
 995
 996     virtual UBool hasNext() {
 997         return pos<LENGTHOF(s);
 998     }
 999
1000     virtual UChar first() {
1001         pos=0;
1002         return s[0];
1003     }
1004
1005     virtual UChar32 first32() {
1006         UChar32 c;
1007         pos=0;
1008         U16_NEXT(s, pos, LENGTHOF(s), c);
1009         pos=0;
1010         return c;
1011     }
1012
1013     virtual UChar setIndex(int32_t position) {
1014         if(0<=position && position<=LENGTHOF(s)) {
1015             pos=position;
1016             if(pos<LENGTHOF(s)) {
1017                 return s[pos];
1018             }
1019         }
1020         return DONE;
1021     }
1022
1023     virtual UChar32 setIndex32(int32_t position) {
1024         if(0<=position && position<=LENGTHOF(s)) {
1025             pos=position;
1026             if(pos<LENGTHOF(s)) {
1027                 UChar32 c;
1028                 U16_GET(s, 0, pos, LENGTHOF(s), c);
1029                 return c;
1030             }
1031         }
1032         return DONE;
1033     }
1034
1035     virtual UChar current() const {
1036         if(pos<LENGTHOF(s)) {
1037             return s[pos];
1038         } else {
1039             return DONE;
1040         }
1041     }
1042
1043     virtual UChar32 current32() const {
1044         if(pos<LENGTHOF(s)) {
1045             UChar32 c;
1046             U16_GET(s, 0, pos, LENGTHOF(s), c);
1047             return c;
1048         } else {
1049             return DONE;
1050         }
1051     }
1052
1053     virtual UChar next() {
1054         if(pos<LENGTHOF(s) && ++pos<LENGTHOF(s)) {
1055             return s[pos];
1056         } else {
1057             return DONE;
1058         }
1059     }
1060
1061     virtual UChar32 next32() {
1062         if(pos<LENGTHOF(s)) {
1063             U16_FWD_1(s, pos, LENGTHOF(s));
1064         }
1065         if(pos<LENGTHOF(s)) {
1066             UChar32 c;
1067             int32_t i=pos;
1068             U16_NEXT(s, i, LENGTHOF(s), c);
1069             return c;
1070         } else {
1071             return DONE;
1072         }
1073     }
1074
1075     virtual UBool hasPrevious() {
1076         return pos>0;
1077     }
1078
1079     virtual void getText(UnicodeString &result) {
1080         result.setTo(s, LENGTHOF(s));
1081     }
1082
1083     // dummy implementations of other pure virtual base class functions
1084     virtual UBool operator==(const ForwardCharacterIterator &that) const {
1085         return
1086             this==&that ||
1087             (typeid(*this)==typeid(that) && pos==((SubCharIter &)that).pos);
1088     }
1089
1090     virtual int32_t hashCode() const {
1091         return 2;
1092     }
1093
1094     virtual CharacterIterator *clone() const {
1095         return NULL;
1096     }
1097
1098     virtual UChar last() {
1099         return 0;
1100     }
1101
1102     virtual UChar32 last32() {
1103         return 0;
1104     }
1105
1106     virtual UChar previous() {
1107         return 0;
1108     }
1109
1110     virtual UChar32 previous32() {
1111         return 0;
1112     }
1113
1114     virtual int32_t move(int32_t /*delta*/, EOrigin /*origin*/) {
1115         return 0;
1116     }
1117
1118     virtual int32_t move32(int32_t /*delta*/, EOrigin /*origin*/) {
1119         return 0;
1120     }
1121
1122     // RTTI
1123     static UClassID getStaticClassID() {
1124         return (UClassID)(&fgClassID);
1125     }
1126
1127     virtual UClassID getDynamicClassID() const {
1128         return getStaticClassID();
1129     }
1130
1131 private:
1132     // dummy string data
1133     UChar s[4];
1134
1135     static const char fgClassID;
1136 };
1137
1138 const char SubCharIter::fgClassID = 0;
1139
1140 class SubStringCharIter : public StringCharacterIterator {
1141 public:
1142     SubStringCharIter() {
1143         setText(UNICODE_STRING("abc", 3));
1144     }
1145 };
1146
1147 class SubUCharCharIter : public UCharCharacterIterator {
1148 public:
1149     SubUCharCharIter() {
1150         setText(u, 3);
1151     }
1152
1153 private:
1154     static const UChar u[3];
1155 };
1156
1157 const UChar SubUCharCharIter::u[3]={ 0x61, 0x62, 0x63 };
1158
1159 void CharIterTest::TestCharIteratorSubClasses() {
1160     SubCharIter *p;
1161
1162     // coverage - call functions that are not otherwise tested
1163     // first[32]PostInc() are default implementations that are overridden
1164     // in ICU's own CharacterIterator subclasses
1165     p=new SubCharIter;
1166     if(p->firstPostInc()!=0x61) {
1167         errln("SubCharIter.firstPosInc() failed\n");
1168     }
1169     delete p;
1170
1171     p=new SubCharIter[2];
1172     if(p[1].first32PostInc()!=0x61) {
1173         errln("SubCharIter.first32PosInc() failed\n");
1174     }
1175     delete [] p;
1176
1177     // coverage: StringCharacterIterator default constructor
1178     SubStringCharIter sci;
1179     if(sci.firstPostInc()!=0x61) {
1180         errln("SubStringCharIter.firstPostInc() failed\n");
1181     }
1182
1183     // coverage: UCharCharacterIterator default constructor
1184     SubUCharCharIter uci;
1185     if(uci.firstPostInc()!=0x61) {
1186         errln("SubUCharCharIter.firstPostInc() failed\n");
1187     }
1188 }