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