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