| /* | |
| ******************************************************************************* | |
| * | |
| * Copyright (C) 2003-2014, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| * | |
| ******************************************************************************* | |
| * file name: uciter8.c | |
| * encoding: US-ASCII | |
| * tab size: 8 (not used) | |
| * indentation:4 | |
| * | |
| * created on: 2003jan10 | |
| * created by: Markus W. Scherer | |
| * | |
| * This file contains sample code that illustrates reading | |
| * 8-bit Unicode text leniently, accepting a mix of UTF-8 and CESU-8 | |
| * and also accepting single surrogates. | |
| */ | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include "unicode/utypes.h" | |
| #include "unicode/uiter.h" | |
| #include "uit_len8.h" | |
| #define log_err printf | |
| /* UCharIterator test ------------------------------------------------------- */ | |
| /* | |
| * The following code is a copy of the UCharIterator test code in | |
| * source/test/cintltst/custrtst.c, | |
| * testing the lenient-8 iterator instead of the UTF-8 one. | |
| */ | |
| /* | |
| * Compare results from two iterators, should be same. | |
| * Assume that the text is not empty and that | |
| * iteration start==0 and iteration limit==length. | |
| */ | |
| static void | |
| compareIterators(UCharIterator *iter1, const char *n1, | |
| UCharIterator *iter2, const char *n2) { | |
| int32_t i, pos1, pos2, middle, length; | |
| UChar32 c1, c2; | |
| /* compare lengths */ | |
| length=iter1->getIndex(iter1, UITER_LENGTH); | |
| pos2=iter2->getIndex(iter2, UITER_LENGTH); | |
| if(length!=pos2) { | |
| log_err("%s->getIndex(length)=%d != %d=%s->getIndex(length)\n", n1, length, pos2, n2); | |
| return; | |
| } | |
| /* set into the middle */ | |
| middle=length/2; | |
| pos1=iter1->move(iter1, middle, UITER_ZERO); | |
| if(pos1!=middle) { | |
| log_err("%s->move(from 0 to middle %d)=%d does not move to the middle\n", n1, middle, pos1); | |
| return; | |
| } | |
| pos2=iter2->move(iter2, middle, UITER_ZERO); | |
| if(pos2!=middle) { | |
| log_err("%s->move(from 0 to middle %d)=%d does not move to the middle\n", n2, middle, pos2); | |
| return; | |
| } | |
| /* test current() */ | |
| c1=iter1->current(iter1); | |
| c2=iter2->current(iter2); | |
| if(c1!=c2) { | |
| log_err("%s->current()=U+%04x != U+%04x=%s->current() at middle=%d\n", n1, c1, c2, n2, middle); | |
| return; | |
| } | |
| /* move forward 3 UChars */ | |
| for(i=0; i<3; ++i) { | |
| c1=iter1->next(iter1); | |
| c2=iter2->next(iter2); | |
| if(c1!=c2) { | |
| log_err("%s->next()=U+%04x != U+%04x=%s->next() at %d (started in middle)\n", n1, c1, c2, n2, iter1->getIndex(iter1, UITER_CURRENT)); | |
| return; | |
| } | |
| } | |
| /* move backward 5 UChars */ | |
| for(i=0; i<5; ++i) { | |
| c1=iter1->previous(iter1); | |
| c2=iter2->previous(iter2); | |
| if(c1!=c2) { | |
| log_err("%s->previous()=U+%04x != U+%04x=%s->previous() at %d (started in middle)\n", n1, c1, c2, n2, iter1->getIndex(iter1, UITER_CURRENT)); | |
| return; | |
| } | |
| } | |
| /* iterate forward from the beginning */ | |
| pos1=iter1->move(iter1, 0, UITER_START); | |
| if(pos1<0) { | |
| log_err("%s->move(start) failed\n", n1); | |
| return; | |
| } | |
| if(!iter1->hasNext(iter1)) { | |
| log_err("%s->hasNext() at the start returns FALSE\n", n1); | |
| return; | |
| } | |
| pos2=iter2->move(iter2, 0, UITER_START); | |
| if(pos2<0) { | |
| log_err("%s->move(start) failed\n", n2); | |
| return; | |
| } | |
| if(!iter2->hasNext(iter2)) { | |
| log_err("%s->hasNext() at the start returns FALSE\n", n2); | |
| return; | |
| } | |
| do { | |
| c1=iter1->next(iter1); | |
| c2=iter2->next(iter2); | |
| if(c1!=c2) { | |
| log_err("%s->next()=U+%04x != U+%04x=%s->next() at %d\n", n1, c1, c2, n2, iter1->getIndex(iter1, UITER_CURRENT)); | |
| return; | |
| } | |
| } while(c1>=0); | |
| if(iter1->hasNext(iter1)) { | |
| log_err("%s->hasNext() at the end returns TRUE\n", n1); | |
| return; | |
| } | |
| if(iter2->hasNext(iter2)) { | |
| log_err("%s->hasNext() at the end returns TRUE\n", n2); | |
| return; | |
| } | |
| /* back to the middle */ | |
| pos1=iter1->move(iter1, middle, UITER_ZERO); | |
| if(pos1!=middle) { | |
| log_err("%s->move(from end to middle %d)=%d does not move to the middle\n", n1, middle, pos1); | |
| return; | |
| } | |
| pos2=iter2->move(iter2, middle, UITER_ZERO); | |
| if(pos2!=middle) { | |
| log_err("%s->move(from end to middle %d)=%d does not move to the middle\n", n2, middle, pos2); | |
| return; | |
| } | |
| /* move to index 1 */ | |
| pos1=iter1->move(iter1, 1, UITER_ZERO); | |
| if(pos1!=1) { | |
| log_err("%s->move(from middle %d to 1)=%d does not move to 1\n", n1, middle, pos1); | |
| return; | |
| } | |
| pos2=iter2->move(iter2, 1, UITER_ZERO); | |
| if(pos2!=1) { | |
| log_err("%s->move(from middle %d to 1)=%d does not move to 1\n", n2, middle, pos2); | |
| return; | |
| } | |
| /* iterate backward from the end */ | |
| pos1=iter1->move(iter1, 0, UITER_LIMIT); | |
| if(pos1<0) { | |
| log_err("%s->move(limit) failed\n", n1); | |
| return; | |
| } | |
| if(!iter1->hasPrevious(iter1)) { | |
| log_err("%s->hasPrevious() at the end returns FALSE\n", n1); | |
| return; | |
| } | |
| pos2=iter2->move(iter2, 0, UITER_LIMIT); | |
| if(pos2<0) { | |
| log_err("%s->move(limit) failed\n", n2); | |
| return; | |
| } | |
| if(!iter2->hasPrevious(iter2)) { | |
| log_err("%s->hasPrevious() at the end returns FALSE\n", n2); | |
| return; | |
| } | |
| do { | |
| c1=iter1->previous(iter1); | |
| c2=iter2->previous(iter2); | |
| if(c1!=c2) { | |
| log_err("%s->previous()=U+%04x != U+%04x=%s->previous() at %d\n", n1, c1, c2, n2, iter1->getIndex(iter1, UITER_CURRENT)); | |
| return; | |
| } | |
| } while(c1>=0); | |
| if(iter1->hasPrevious(iter1)) { | |
| log_err("%s->hasPrevious() at the start returns TRUE\n", n1); | |
| return; | |
| } | |
| if(iter2->hasPrevious(iter2)) { | |
| log_err("%s->hasPrevious() at the start returns TRUE\n", n2); | |
| return; | |
| } | |
| } | |
| /* | |
| * Test the iterator's getState() and setState() functions. | |
| * iter1 and iter2 must be set up for the same iterator type and the same string | |
| * but may be physically different structs (different addresses). | |
| * | |
| * Assume that the text is not empty and that | |
| * iteration start==0 and iteration limit==length. | |
| * It must be 2<=middle<=length-2. | |
| */ | |
| static void | |
| testIteratorState(UCharIterator *iter1, UCharIterator *iter2, const char *n, int32_t middle) { | |
| UChar32 u[4]; | |
| UErrorCode errorCode; | |
| UChar32 c; | |
| uint32_t state; | |
| int32_t i, j; | |
| /* get four UChars from the middle of the string */ | |
| iter1->move(iter1, middle-2, UITER_ZERO); | |
| for(i=0; i<4; ++i) { | |
| c=iter1->next(iter1); | |
| if(c<0) { | |
| /* the test violates the assumptions, see comment above */ | |
| log_err("test error: %s[%d]=%d\n", n, middle-2+i, c); | |
| return; | |
| } | |
| u[i]=c; | |
| } | |
| /* move to the middle and get the state */ | |
| iter1->move(iter1, -2, UITER_CURRENT); | |
| state=uiter_getState(iter1); | |
| /* set the state into the second iterator and compare the results */ | |
| errorCode=U_ZERO_ERROR; | |
| uiter_setState(iter2, state, &errorCode); | |
| if(U_FAILURE(errorCode)) { | |
| log_err("%s->setState(0x%x) failed: %s\n", n, state, u_errorName(errorCode)); | |
| return; | |
| } | |
| c=iter2->current(iter2); | |
| if(c!=u[2]) { | |
| log_err("%s->current(at %d)=U+%04x!=U+%04x\n", n, middle, c, u[2]); | |
| } | |
| c=iter2->previous(iter2); | |
| if(c!=u[1]) { | |
| log_err("%s->previous(at %d)=U+%04x!=U+%04x\n", n, middle-1, c, u[1]); | |
| } | |
| iter2->move(iter2, 2, UITER_CURRENT); | |
| c=iter2->next(iter2); | |
| if(c!=u[3]) { | |
| log_err("%s->next(at %d)=U+%04x!=U+%04x\n", n, middle+1, c, u[3]); | |
| } | |
| iter2->move(iter2, -3, UITER_CURRENT); | |
| c=iter2->previous(iter2); | |
| if(c!=u[0]) { | |
| log_err("%s->previous(at %d)=U+%04x!=U+%04x\n", n, middle-2, c, u[0]); | |
| } | |
| /* move the second iterator back to the middle */ | |
| iter2->move(iter2, 1, UITER_CURRENT); | |
| iter2->next(iter2); | |
| /* check that both are in the middle */ | |
| i=iter1->getIndex(iter1, UITER_CURRENT); | |
| j=iter2->getIndex(iter2, UITER_CURRENT); | |
| if(i!=middle) { | |
| log_err("%s->getIndex(current)=%d!=%d as expected\n", n, i, middle); | |
| } | |
| if(i!=j) { | |
| log_err("%s->getIndex(current)=%d!=%d after setState()\n", n, j, i); | |
| } | |
| /* compare lengths */ | |
| i=iter1->getIndex(iter1, UITER_LENGTH); | |
| j=iter2->getIndex(iter2, UITER_LENGTH); | |
| if(i!=j) { | |
| log_err("%s->getIndex(length)=%d!=%d before/after setState()\n", n, i, j); | |
| } | |
| } | |
| static void | |
| TestLenient8Iterator() { | |
| static const UChar text[]={ | |
| 0x61, 0x62, 0x63, | |
| /* dffd 107fd d801 dffd - in UTF-16, U+107fd=<d801 dffd> */ | |
| 0xdffd, 0xd801, 0xdffd, 0xd801, 0xdffd, | |
| 0x78, 0x79, 0x7a, 0 | |
| }; | |
| static const uint8_t bytes[]={ | |
| 0x61, 0x62, 0x63, | |
| /* dffd 107fd d801 dffd - mixture */ | |
| 0xed, 0xbf, 0xbd, 0xf0, 0x90, 0x9f, 0xbd, 0xed, 0xa0, 0x81, 0xed, 0xbf, 0xbd, | |
| 0x78, 0x79, 0x7a, 0 | |
| }; | |
| UCharIterator iter1, iter2; | |
| UChar32 c1, c2; | |
| int32_t length; | |
| puts("test a UCharIterator for lenient 8-bit Unicode (accept single surrogates)"); | |
| /* compare the same string between UTF-16 and lenient-8 UCharIterators */ | |
| uiter_setString(&iter1, text, -1); | |
| uiter_setLenient8(&iter2, (const char *)bytes, sizeof(bytes)-1); | |
| compareIterators(&iter1, "UTF16Iterator", &iter2, "Lenient8Iterator"); | |
| /* try again with length=-1 */ | |
| uiter_setLenient8(&iter2, (const char *)bytes, -1); | |
| compareIterators(&iter1, "UTF16Iterator", &iter2, "Lenient8Iterator_1"); | |
| /* test get/set state */ | |
| length=UPRV_LENGTHOF(text)-1; | |
| uiter_setLenient8(&iter1, (const char*)bytes, -1); | |
| testIteratorState(&iter1, &iter2, "Lenient8IteratorState", length/2); | |
| testIteratorState(&iter1, &iter2, "Lenient8IteratorStatePlus1", length/2+1); | |
| /* ---------------------------------------------------------------------- */ | |
| puts("no output so far means that the lenient-8 iterator works fine"); | |
| puts("iterate forward:\nUTF-16\tlenient-8"); | |
| uiter_setString(&iter1, text, -1); | |
| iter1.move(&iter1, 0, UITER_START); | |
| iter2.move(&iter2, 0, UITER_START); | |
| for(;;) { | |
| c1=iter1.next(&iter1); | |
| c2=iter2.next(&iter2); | |
| if(c1<0 && c2<0) { | |
| break; | |
| } | |
| if(c1<0) { | |
| printf("\t%04x\n", c2); | |
| } else if(c2<0) { | |
| printf("%04x\n", c1); | |
| } else { | |
| printf("%04x\t%04x\n", c1, c2); | |
| } | |
| } | |
| } | |
| extern int | |
| main(int argc, const char *argv[]) { | |
| TestLenient8Iterator(); | |
| return 0; | |
| } |