*/
#include "unicode/utypes.h"
-#include "unicode/utf16.h"
#include "unicode/ustring.h"
+#include "unicode/utf16.h"
+#include "unicode/utf_old.h"
#include "cmemory.h"
#include "cstring.h"
#include "cintltst.h"
#include <stdio.h>
-static void printUChars(const UChar *uchars);
+// Obsolete macro from obsolete unicode/utf_old.h, for some old test data.
+#ifndef UTF_ERROR_VALUE
+# define UTF_ERROR_VALUE 0xffff
+#endif
+
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
+static void printUChars(const UChar *uchars) {
+ int16_t i=0;
+ for(i=0; i<u_strlen(uchars); i++) {
+ printf("%x ", *(uchars+i));
+ }
+}
+#endif
static void TestCodeUnitValues(void);
static void TestCharLength(void);
UChar c=codeunit[i];
log_verbose("Testing code unit value of %x\n", c);
if(i<4){
- if(!UTF16_IS_SINGLE(c) || UTF16_IS_LEAD(c) || UTF16_IS_TRAIL(c) || !U16_IS_SINGLE(c) || U16_IS_LEAD(c) || U16_IS_TRAIL(c)){
+ if(
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
+ !UTF16_IS_SINGLE(c) || UTF16_IS_LEAD(c) || UTF16_IS_TRAIL(c) ||
+#endif
+ !U16_IS_SINGLE(c) || U16_IS_LEAD(c) || U16_IS_TRAIL(c)) {
log_err("ERROR: %x is a single character\n", c);
}
}
if(i >= 4 && i< 8){
- if(!UTF16_IS_LEAD(c) || UTF16_IS_SINGLE(c) || UTF16_IS_TRAIL(c) || !U16_IS_LEAD(c) || U16_IS_SINGLE(c) || U16_IS_TRAIL(c)){
+ if(
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
+ !UTF16_IS_LEAD(c) || UTF16_IS_SINGLE(c) || UTF16_IS_TRAIL(c) ||
+#endif
+ !U16_IS_LEAD(c) || U16_IS_SINGLE(c) || U16_IS_TRAIL(c)){
log_err("ERROR: %x is a first surrogate\n", c);
}
}
if(i >= 8 && i< 12){
- if(!UTF16_IS_TRAIL(c) || UTF16_IS_SINGLE(c) || UTF16_IS_LEAD(c) || !U16_IS_TRAIL(c) || U16_IS_SINGLE(c) || U16_IS_LEAD(c)){
+ if(
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
+ !UTF16_IS_TRAIL(c) || UTF16_IS_SINGLE(c) || UTF16_IS_LEAD(c) ||
+#endif
+ !U16_IS_TRAIL(c) || U16_IS_SINGLE(c) || U16_IS_LEAD(c)) {
log_err("ERROR: %x is a second surrogate\n", c);
}
}
};
int16_t i;
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
UBool multiple;
+#endif
for(i=0; i<UPRV_LENGTHOF(codepoint); i=(int16_t)(i+2)){
UChar32 c=codepoint[i+1];
- if(UTF16_CHAR_LENGTH(c) != (uint16_t)codepoint[i] || U16_LENGTH(c) != (uint16_t)codepoint[i]){
- log_err("The no: of code units for %lx:- Expected: %d Got: %d\n", c, codepoint[i], UTF16_CHAR_LENGTH(c));
+ if(
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
+ UTF16_CHAR_LENGTH(c) != (uint16_t)codepoint[i] ||
+#endif
+ U16_LENGTH(c) != (uint16_t)codepoint[i]) {
+ log_err("The no: of code units for %lx:- Expected: %d Got: %d\n", c, codepoint[i], U16_LENGTH(c));
}else{
- log_verbose("The no: of code units for %lx is %d\n",c, UTF16_CHAR_LENGTH(c) );
+ log_verbose("The no: of code units for %lx is %d\n",c, U16_LENGTH(c));
}
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
multiple=(UBool)(codepoint[i] == 1 ? FALSE : TRUE);
if(UTF16_NEED_MULTIPLE_UCHAR(c) != multiple){
log_err("ERROR: UTF16_NEED_MULTIPLE_UCHAR failed for %lx\n", c);
}
+#endif
}
}
0x11734, 0xd800, UTF_ERROR_VALUE
};
uint16_t i=0;
- UChar32 c;
+ UChar32 c, expected;
uint16_t offset=0;
for(offset=0; offset<UPRV_LENGTHOF(input); offset++) {
if(0<offset && offset<UPRV_LENGTHOF(input)-1){
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
UTF16_GET_CHAR_UNSAFE(input, offset, c);
if(c != result[i]){
log_err("ERROR: UTF16_GET_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i], c);
}
-
+#endif
U16_GET_UNSAFE(input, offset, c);
if(c != result[i]){
log_err("ERROR: U16_GET_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i], c);
}
}
-
+ expected=result[i+1];
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
UTF16_GET_CHAR_SAFE(input, 0, offset, UPRV_LENGTHOF(input), c, FALSE);
- if(c != result[i+1]){
- log_err("ERROR: UTF16_GET_CHAR_SAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+1], c);
+ if(c != expected) {
+ log_err("ERROR: UTF16_GET_CHAR_SAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, expected, c);
}
-
+#endif
U16_GET(input, 0, offset, UPRV_LENGTHOF(input), c);
- if(c != result[i+1]){
- log_err("ERROR: U16_GET failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+1], c);
+ if(c != expected) {
+ log_err("ERROR: U16_GET failed for offset=%ld. Expected:%lx Got:%lx\n", offset, expected, c);
}
+ U16_GET_OR_FFFD(input, 0, offset, UPRV_LENGTHOF(input), c);
+ if(U_IS_SURROGATE(expected)) { expected=0xfffd; }
+ if(c != expected) {
+ log_err("ERROR: U16_GET_OR_FFFD failed for offset=%ld. Expected:%lx Got:%lx\n", offset, expected, c);
+ }
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
UTF16_GET_CHAR_SAFE(input, 0, offset, UPRV_LENGTHOF(input), c, TRUE);
if(c != result[i+2]){
log_err("ERROR: UTF16_GET_CHAR_SAFE(strict) failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+2], c);
}
+#endif
i=(uint16_t)(i+3);
}
-
}
static void TestNextPrevChar(){
};
- UChar32 c=0x0000;
+ UChar32 c=0x0000, expected;
uint16_t i=0;
uint16_t offset=0, setOffset=0;
for(offset=0; offset<UPRV_LENGTHOF(input); offset++){
setOffset=offset;
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
UTF16_NEXT_CHAR_UNSAFE(input, setOffset, c);
if(setOffset != movedOffset[i]){
log_err("ERROR: UTF16_NEXT_CHAR_UNSAFE failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
if(c != result[i]){
log_err("ERROR: UTF16_NEXT_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i], c);
}
-
+#endif
setOffset=offset;
U16_NEXT_UNSAFE(input, setOffset, c);
if(setOffset != movedOffset[i]){
if(c != result[i]){
log_err("ERROR: U16_NEXT_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i], c);
}
-
+ expected=result[i+1];
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
setOffset=offset;
UTF16_NEXT_CHAR_SAFE(input, setOffset, UPRV_LENGTHOF(input), c, FALSE);
if(setOffset != movedOffset[i+1]){
log_err("ERROR: UTF16_NEXT_CHAR_SAFE failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
offset, movedOffset[i+1], setOffset);
}
- if(c != result[i+1]){
- log_err("ERROR: UTF16_NEXT_CHAR_SAFE failed for input=%ld. Expected:%lx Got:%lx\n", offset, result[i+1], c);
- }
-
+ if(c != expected) {
+ log_err("ERROR: UTF16_NEXT_CHAR_SAFE failed for input=%ld. Expected:%lx Got:%lx\n", offset, expected, c);
+ }
+#endif
setOffset=offset;
U16_NEXT(input, setOffset, UPRV_LENGTHOF(input), c);
if(setOffset != movedOffset[i+1]){
log_err("ERROR: U16_NEXT failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
offset, movedOffset[i+1], setOffset);
}
- if(c != result[i+1]){
- log_err("ERROR: U16_NEXT failed for input=%ld. Expected:%lx Got:%lx\n", offset, result[i+1], c);
- }
+ if(c != expected){
+ log_err("ERROR: U16_NEXT failed for input=%ld. Expected:%lx Got:%lx\n", offset, expected, c);
+ }
+ setOffset=offset;
+ U16_NEXT_OR_FFFD(input, setOffset, UPRV_LENGTHOF(input), c);
+ if(setOffset != movedOffset[i+1]){
+ log_err("ERROR: U16_NEXT_OR_FFFD failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
+ offset, movedOffset[i+1], setOffset);
+ }
+ if(U_IS_SURROGATE(expected)) { expected=0xfffd; }
+ if(c != expected){
+ log_err("ERROR: U16_NEXT_OR_FFFD failed for input=%ld. Expected:%lx Got:%lx\n", offset, expected, c);
+ }
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
setOffset=offset;
UTF16_NEXT_CHAR_SAFE(input, setOffset, UPRV_LENGTHOF(input), c, TRUE);
if(setOffset != movedOffset[i+1]){
if(c != result[i+2]){
log_err("ERROR: UTF16_NEXT_CHAR_SAFE(strict) failed for input=%ld. Expected:%lx Got:%lx\n", offset, result[i+2], c);
}
-
+#endif
i=(uint16_t)(i+6);
}
i=0;
for(offset=(uint16_t)UPRV_LENGTHOF(input); offset > 0; --offset){
setOffset=offset;
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
UTF16_PREV_CHAR_UNSAFE(input, setOffset, c);
if(setOffset != movedOffset[i+3]){
log_err("ERROR: UTF16_PREV_CHAR_UNSAFE failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
if(c != result[i+3]){
log_err("ERROR: UTF16_PREV_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+3], c);
}
-
+#endif
setOffset=offset;
U16_PREV_UNSAFE(input, setOffset, c);
if(setOffset != movedOffset[i+3]){
if(c != result[i+3]){
log_err("ERROR: U16_PREV_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+3], c);
}
-
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
setOffset=offset;
UTF16_PREV_CHAR_SAFE(input, 0, setOffset, c, FALSE);
if(setOffset != movedOffset[i+4]){
if(c != result[i+4]){
log_err("ERROR: UTF16_PREV_CHAR_SAFE failed for input=%ld. Expected:%lx Got:%lx\n", offset, result[i+4], c);
}
-
+#endif
setOffset=offset;
U16_PREV(input, 0, setOffset, c);
if(setOffset != movedOffset[i+4]){
log_err("ERROR: U16_PREV failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
offset, movedOffset[i+4], setOffset);
}
- if(c != result[i+4]){
- log_err("ERROR: U16_PREV failed for input=%ld. Expected:%lx Got:%lx\n", offset, result[i+4], c);
- }
+ expected = result[i+4];
+ if(c != expected) {
+ log_err("ERROR: U16_PREV failed for input=%ld. Expected:%lx Got:%lx\n", offset, expected, c);
+ }
+ setOffset=offset;
+ U16_PREV_OR_FFFD(input, 0, setOffset, c);
+ if(setOffset != movedOffset[i+4]){
+ log_err("ERROR: U16_PREV_OR_FFFD failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
+ offset, movedOffset[i+4], setOffset);
+ }
+ if(U_IS_SURROGATE(expected)) { expected=0xfffd; }
+ if(c != expected) {
+ log_err("ERROR: U16_PREV_OR_FFFD failed for input=%ld. Expected:%lx Got:%lx\n", offset, expected, c);
+ }
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
setOffset=offset;
UTF16_PREV_CHAR_SAFE(input, 0, setOffset, c, TRUE);
if(setOffset != movedOffset[i+5]){
if(c != result[i+5]){
log_err("ERROR: UTF16_PREV_CHAR_SAFE(strict) failed for input=%ld. Expected:%lx Got:%lx\n", offset, result[i+5], c);
}
-
+#endif
i=(uint16_t)(i+6);
}
0
};
- UChar32 c, c2;
+ UChar32 c, c2, expected;
int32_t i0, i=0, j, k, expectedIndex;
int32_t cpIndex=0;
do {
i0=i;
U16_NEXT(input, i, -1, c);
- if(c!=result[cpIndex]) {
- log_err("U16_NEXT(from %d)=U+%04x != U+%04x\n", i0, c, result[cpIndex]);
+ expected=result[cpIndex];
+ if(c!=expected) {
+ log_err("U16_NEXT(from %d)=U+%04x != U+%04x\n", i0, c, expected);
+ }
+ j=i0;
+ U16_NEXT_OR_FFFD(input, j, -1, c);
+ if(U_IS_SURROGATE(expected)) { expected=0xfffd; }
+ if(c!=expected) {
+ log_err("U16_NEXT_OR_FFFD(from %d)=U+%04x != U+%04x\n", i0, c, expected);
+ }
+ if(j!=i) {
+ log_err("U16_NEXT_OR_FFFD() moved to index %d but U16_NEXT() moved to %d\n", j, i);
}
j=i0;
U16_FWD_1(input, j, -1);
if(c2!=c) {
log_err("U16_NEXT(from %d)=U+%04x != U+%04x=U16_GET(at %d)\n", i0, c, c2, j);
}
+ U16_GET_OR_FFFD(input, 0, j, -1, c2);
+ expected= U_IS_SURROGATE(c) ? 0xfffd : c;
+ if(c2!=expected) {
+ log_err("U16_NEXT_OR_FFFD(from %d)=U+%04x != U+%04x=U16_GET_OR_FFFD(at %d)\n", i0, expected, c2, j);
+ }
/* U16_SET_CP_LIMIT moves from a non-lead byte to the limit of the code point */
k=j+1;
U16_SET_CP_LIMIT(input, 0, k, -1);
uint16_t offunsafe=0, offsafe=0;
uint16_t i=0;
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
while(offunsafe < UPRV_LENGTHOF(input)){
UTF16_FWD_1_UNSAFE(input, offunsafe);
if(offunsafe != fwd_unsafe[i]){
}
i++;
}
-
+#endif
offunsafe=0, offsafe=0;
i=0;
while(offunsafe < UPRV_LENGTHOF(input)){
}
i++;
}
-
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
+ offunsafe=0, offsafe=0;
i=0;
while(offsafe < UPRV_LENGTHOF(input)){
UTF16_FWD_1_SAFE(input, offsafe, UPRV_LENGTHOF(input));
}
i++;
}
-
+#endif
+ offunsafe=0, offsafe=0;
i=0;
while(offsafe < UPRV_LENGTHOF(input)){
U16_FWD_1(input, offsafe, UPRV_LENGTHOF(input));
}
i++;
}
-
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
offunsafe=UPRV_LENGTHOF(input);
offsafe=UPRV_LENGTHOF(input);
i=0;
}
i++;
}
-
+#endif
offunsafe=UPRV_LENGTHOF(input);
offsafe=UPRV_LENGTHOF(input);
i=0;
}
i++;
}
-
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
+ offunsafe=UPRV_LENGTHOF(input);
+ offsafe=UPRV_LENGTHOF(input);
i=0;
while(offsafe > 0){
UTF16_BACK_1_SAFE(input,0, offsafe);
}
i++;
}
-
+#endif
+ offunsafe=UPRV_LENGTHOF(input);
+ offsafe=UPRV_LENGTHOF(input);
i=0;
while(offsafe > 0){
U16_BACK_1(input,0, offsafe);
offunsafe=0;
offsafe=0;
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
for(i=0; i<UPRV_LENGTHOF(Nvalue)-2; i++){ /*didn't want it to fail(we assume 0<i<length)*/
UTF16_FWD_N_UNSAFE(input, offunsafe, Nvalue[i]);
if(offunsafe != fwd_N_unsafe[i]){
log_err("ERROR: Forward_N_unsafe offset expected:%d, Got:%d\n", fwd_N_unsafe[i], offunsafe);
}
}
-
+#endif
offunsafe=0;
for(i=0; i<UPRV_LENGTHOF(Nvalue)-2; i++){ /*didn't want it to fail(we assume 0<i<length)*/
U16_FWD_N_UNSAFE(input, offunsafe, Nvalue[i]);
log_err("ERROR: U16_FWD_N_UNSAFE offset expected:%d, Got:%d\n", fwd_N_unsafe[i], offunsafe);
}
}
-
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
offsafe=0;
for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
UTF16_FWD_N_SAFE(input, offsafe, UPRV_LENGTHOF(input), Nvalue[i]);
if(offsafe != fwd_N_safe[i]){
log_err("ERROR: Forward_N_safe offset expected:%d, Got:%d\n", fwd_N_safe[i], offsafe);
}
-
}
-
+#endif
offsafe=0;
for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
U16_FWD_N(input, offsafe, UPRV_LENGTHOF(input), Nvalue[i]);
if(offsafe != fwd_N_safe[i]){
log_err("ERROR: U16_FWD_N offset expected:%d, Got:%d\n", fwd_N_safe[i], offsafe);
}
-
}
-
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
offunsafe=UPRV_LENGTHOF(input);
for(i=0; i<UPRV_LENGTHOF(Nvalue)-2; i++){
UTF16_BACK_N_UNSAFE(input, offunsafe, Nvalue[i]);
log_err("ERROR: backward_N_unsafe offset expected:%d, Got:%d\n", back_N_unsafe[i], offunsafe);
}
}
-
+#endif
offunsafe=UPRV_LENGTHOF(input);
for(i=0; i<UPRV_LENGTHOF(Nvalue)-2; i++){
U16_BACK_N_UNSAFE(input, offunsafe, Nvalue[i]);
log_err("ERROR: U16_BACK_N_UNSAFE offset expected:%d, Got:%d\n", back_N_unsafe[i], offunsafe);
}
}
-
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
offsafe=UPRV_LENGTHOF(input);
for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
UTF16_BACK_N_SAFE(input, 0, offsafe, Nvalue[i]);
log_err("ERROR: backward_N_safe offset expected:%d, Got:%d\n", back_N_safe[i], offsafe);
}
}
-
+#endif
offsafe=UPRV_LENGTHOF(input);
for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
U16_BACK_N(input, 0, offsafe, Nvalue[i]);
uint16_t i=0;
uint16_t offset=0, setOffset=0;
for(offset=0; offset<UPRV_LENGTHOF(input); offset++){
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
setOffset=offset;
UTF16_SET_CHAR_START_UNSAFE(input, setOffset);
if(setOffset != start_unsafe[i]){
log_err("ERROR: UTF16_SET_CHAR_START_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, start_unsafe[i], setOffset);
}
-
+#endif
setOffset=offset;
U16_SET_CP_START_UNSAFE(input, setOffset);
if(setOffset != start_unsafe[i]){
log_err("ERROR: U16_SET_CHAR_START_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, start_unsafe[i], setOffset);
}
-
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
setOffset=offset;
UTF16_SET_CHAR_START_SAFE(input, 0, setOffset);
if(setOffset != start_safe[i]){
log_err("ERROR: UTF16_SET_CHAR_START_SAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, start_safe[i], setOffset);
}
-
+#endif
setOffset=offset;
U16_SET_CP_START(input, 0, setOffset);
if(setOffset != start_safe[i]){
}
if (offset > 0) {
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
setOffset=offset;
UTF16_SET_CHAR_LIMIT_UNSAFE(input, setOffset);
if(setOffset != limit_unsafe[i]){
log_err("ERROR: UTF16_SET_CHAR_LIMIT_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, limit_unsafe[i], setOffset);
}
-
+#endif
setOffset=offset;
U16_SET_CP_LIMIT_UNSAFE(input, setOffset);
if(setOffset != limit_unsafe[i]){
}
static void TestAppendChar(){
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
static UChar s[5]={0x0061, 0x0062, 0x0063, 0x0064, 0x0000};
static uint32_t test[]={
/*append-position(unsafe), CHAR to be appended */
count++;
}
free(str);
-
+#endif
}
static void TestAppend() {
static UChar32 s[] = {0x10000, 0x10ffff, 0x50000, 0x100000, 0x1abcd};
int i = 0;
while (i < 5) {
- UChar first = UTF_FIRST_SURROGATE(s[i]);
- UChar second = UTF_SECOND_SURROGATE(s[i]);
+ UChar first = U16_LEAD(s[i]);
+ UChar second = U16_TRAIL(s[i]);
/* algorithm from the Unicode consortium */
UChar firstresult = (UChar)(((s[i] - 0x10000) / 0x400) + 0xD800);
UChar secondresult = (UChar)(((s[i] - 0x10000) % 0x400) + 0xDC00);
- if (first != UTF16_LEAD(s[i]) || first != U16_LEAD(s[i]) || first != firstresult) {
+ if (
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
+ first != UTF16_LEAD(s[i]) || first != UTF_FIRST_SURROGATE(s[i]) ||
+#endif
+ first != firstresult) {
log_err("Failure in first surrogate in 0x%x expected to be 0x%x\n",
s[i], firstresult);
}
- if (second != UTF16_TRAIL(s[i]) || second != U16_TRAIL(s[i]) || second != secondresult) {
+ if (
+#if !U_HIDE_OBSOLETE_UTF_OLD_H
+ second != UTF16_TRAIL(s[i]) || second != UTF_SECOND_SURROGATE(s[i]) ||
+#endif
+ second != secondresult) {
log_err("Failure in second surrogate in 0x%x expected to be 0x%x\n",
s[i], secondresult);
}
i ++;
}
}
-
-static void printUChars(const UChar *uchars){
- int16_t i=0;
- for(i=0; i<u_strlen(uchars); i++){
- printf("%x ", *(uchars+i));
- }
-}
projects / apple / icu.git / blobdiff