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) 1998-2016, International Business Machines Corporation and 6 * others. All Rights Reserved. 7 ********************************************************************/ 8 /* 9 * File test.c 10 * 11 * Modification History: 12 * 13 * Date Name Description 14 * 05/01/2000 Madhu Creation 15 ******************************************************************************* 16 */ 17 18 #include "unicode/utypes.h" 19 #include "unicode/ustring.h" 20 #include "unicode/utf16.h" 21 #include "unicode/utf_old.h" 22 #include "cmemory.h" 23 #include "cstring.h" 24 #include "cintltst.h" 25 #include <stdio.h> 26 27 // Obsolete macro from obsolete unicode/utf_old.h, for some old test data. 28 #ifndef UTF_ERROR_VALUE 29 # define UTF_ERROR_VALUE 0xffff 30 #endif 31 32 #if !U_HIDE_OBSOLETE_UTF_OLD_H 33 static void printUChars(const UChar *uchars) { 34 int16_t i=0; 35 for(i=0; i<u_strlen(uchars); i++) { 36 printf("%x ", *(uchars+i)); 37 } 38 } 39 #endif 40 41 static void TestCodeUnitValues(void); 42 static void TestCharLength(void); 43 static void TestGetChar(void); 44 static void TestNextPrevChar(void); 45 static void TestNulTerminated(void); 46 static void TestFwdBack(void); 47 static void TestSetChar(void); 48 static void TestAppendChar(void); 49 static void TestAppend(void); 50 static void TestSurrogate(void); 51 52 void addUTF16Test(TestNode** root); 53 54 void 55 addUTF16Test(TestNode** root) 56 { 57 addTest(root, &TestCodeUnitValues, "utf16tst/TestCodeUnitValues"); 58 addTest(root, &TestCharLength, "utf16tst/TestCharLength"); 59 addTest(root, &TestGetChar, "utf16tst/TestGetChar"); 60 addTest(root, &TestNextPrevChar, "utf16tst/TestNextPrevChar"); 61 addTest(root, &TestNulTerminated, "utf16tst/TestNulTerminated"); 62 addTest(root, &TestFwdBack, "utf16tst/TestFwdBack"); 63 addTest(root, &TestSetChar, "utf16tst/TestSetChar"); 64 addTest(root, &TestAppendChar, "utf16tst/TestAppendChar"); 65 addTest(root, &TestAppend, "utf16tst/TestAppend"); 66 addTest(root, &TestSurrogate, "utf16tst/TestSurrogate"); 67 } 68 69 static void TestCodeUnitValues() 70 { 71 static uint16_t codeunit[]={0x0000,0xe065,0x20ac,0xd7ff,0xd800,0xd841,0xd905,0xdbff,0xdc00,0xdc02,0xddee,0xdfff,0}; 72 73 int16_t i; 74 for(i=0; i<UPRV_LENGTHOF(codeunit); i++){ 75 UChar c=codeunit[i]; 76 log_verbose("Testing code unit value of %x\n", c); 77 if(i<4){ 78 if( 79 #if !U_HIDE_OBSOLETE_UTF_OLD_H 80 !UTF16_IS_SINGLE(c) || UTF16_IS_LEAD(c) || UTF16_IS_TRAIL(c) || 81 #endif 82 !U16_IS_SINGLE(c) || U16_IS_LEAD(c) || U16_IS_TRAIL(c)) { 83 log_err("ERROR: %x is a single character\n", c); 84 } 85 } 86 if(i >= 4 && i< 8){ 87 if( 88 #if !U_HIDE_OBSOLETE_UTF_OLD_H 89 !UTF16_IS_LEAD(c) || UTF16_IS_SINGLE(c) || UTF16_IS_TRAIL(c) || 90 #endif 91 !U16_IS_LEAD(c) || U16_IS_SINGLE(c) || U16_IS_TRAIL(c)){ 92 log_err("ERROR: %x is a first surrogate\n", c); 93 } 94 } 95 if(i >= 8 && i< 12){ 96 if( 97 #if !U_HIDE_OBSOLETE_UTF_OLD_H 98 !UTF16_IS_TRAIL(c) || UTF16_IS_SINGLE(c) || UTF16_IS_LEAD(c) || 99 #endif 100 !U16_IS_TRAIL(c) || U16_IS_SINGLE(c) || U16_IS_LEAD(c)) { 101 log_err("ERROR: %x is a second surrogate\n", c); 102 } 103 } 104 } 105 } 106 107 static void TestCharLength() 108 { 109 static uint32_t codepoint[]={ 110 1, 0x0061, 111 1, 0xe065, 112 1, 0x20ac, 113 2, 0x20402, 114 2, 0x23456, 115 2, 0x24506, 116 2, 0x20402, 117 2, 0x10402, 118 1, 0xd7ff, 119 1, 0xe000 120 }; 121 122 int16_t i; 123 #if !U_HIDE_OBSOLETE_UTF_OLD_H 124 UBool multiple; 125 #endif 126 for(i=0; i<UPRV_LENGTHOF(codepoint); i=(int16_t)(i+2)){ 127 UChar32 c=codepoint[i+1]; 128 if( 129 #if !U_HIDE_OBSOLETE_UTF_OLD_H 130 UTF16_CHAR_LENGTH(c) != (uint16_t)codepoint[i] || 131 #endif 132 U16_LENGTH(c) != (uint16_t)codepoint[i]) { 133 log_err("The no: of code units for %lx:- Expected: %d Got: %d\n", c, codepoint[i], U16_LENGTH(c)); 134 }else{ 135 log_verbose("The no: of code units for %lx is %d\n",c, U16_LENGTH(c)); 136 } 137 #if !U_HIDE_OBSOLETE_UTF_OLD_H 138 multiple=(UBool)(codepoint[i] == 1 ? FALSE : TRUE); 139 if(UTF16_NEED_MULTIPLE_UCHAR(c) != multiple){ 140 log_err("ERROR: UTF16_NEED_MULTIPLE_UCHAR failed for %lx\n", c); 141 } 142 #endif 143 } 144 } 145 146 static void TestGetChar() 147 { 148 static UChar input[]={ 149 /* code unit,*/ 150 0xdc00, 151 0x20ac, 152 0xd841, 153 0x61, 154 0xd841, 155 0xdc02, 156 0xd842, 157 0xdc06, 158 0, 159 0xd842, 160 0xd7ff, 161 0xdc41, 162 0xe000, 163 0xd800 164 }; 165 static UChar32 result[]={ 166 /*codepoint-unsafe, codepoint-safe(not strict) codepoint-safe(strict)*/ 167 (UChar32)0xfca10000, 0xdc00, UTF_ERROR_VALUE, 168 0x20ac, 0x20ac, 0x20ac, 169 0x12861, 0xd841, UTF_ERROR_VALUE, 170 0x61, 0x61, 0x61, 171 0x20402, 0x20402, 0x20402, 172 0x20402, 0x20402, 0x20402, 173 0x20806, 0x20806, 0x20806, 174 0x20806, 0x20806, 0x20806, 175 0x00, 0x00, 0x00, 176 0x203ff, 0xd842, UTF_ERROR_VALUE, 177 0xd7ff, 0xd7ff, 0xd7ff, 178 0xfc41, 0xdc41, UTF_ERROR_VALUE, 179 0xe000, 0xe000, 0xe000, 180 0x11734, 0xd800, UTF_ERROR_VALUE 181 }; 182 uint16_t i=0; 183 UChar32 c, expected; 184 uint16_t offset=0; 185 for(offset=0; offset<UPRV_LENGTHOF(input); offset++) { 186 if(0<offset && offset<UPRV_LENGTHOF(input)-1){ 187 #if !U_HIDE_OBSOLETE_UTF_OLD_H 188 UTF16_GET_CHAR_UNSAFE(input, offset, c); 189 if(c != result[i]){ 190 log_err("ERROR: UTF16_GET_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i], c); 191 } 192 #endif 193 U16_GET_UNSAFE(input, offset, c); 194 if(c != result[i]){ 195 log_err("ERROR: U16_GET_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i], c); 196 } 197 } 198 expected=result[i+1]; 199 #if !U_HIDE_OBSOLETE_UTF_OLD_H 200 UTF16_GET_CHAR_SAFE(input, 0, offset, UPRV_LENGTHOF(input), c, FALSE); 201 if(c != expected) { 202 log_err("ERROR: UTF16_GET_CHAR_SAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, expected, c); 203 } 204 #endif 205 U16_GET(input, 0, offset, UPRV_LENGTHOF(input), c); 206 if(c != expected) { 207 log_err("ERROR: U16_GET failed for offset=%ld. Expected:%lx Got:%lx\n", offset, expected, c); 208 } 209 210 U16_GET_OR_FFFD(input, 0, offset, UPRV_LENGTHOF(input), c); 211 if(U_IS_SURROGATE(expected)) { expected=0xfffd; } 212 if(c != expected) { 213 log_err("ERROR: U16_GET_OR_FFFD failed for offset=%ld. Expected:%lx Got:%lx\n", offset, expected, c); 214 } 215 #if !U_HIDE_OBSOLETE_UTF_OLD_H 216 UTF16_GET_CHAR_SAFE(input, 0, offset, UPRV_LENGTHOF(input), c, TRUE); 217 if(c != result[i+2]){ 218 log_err("ERROR: UTF16_GET_CHAR_SAFE(strict) failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+2], c); 219 } 220 #endif 221 i=(uint16_t)(i+3); 222 } 223 } 224 225 static void TestNextPrevChar(){ 226 227 static UChar input[]={0x0061, 0xd800, 0xdc00, 0xdbff, 0xdfff, 0x0062, 0xd841, 0xd7ff, 0xd841, 0xdc41, 0xdc00, 0x0000}; 228 static UChar32 result[]={ 229 /*next_unsafe next_safe_ns next_safe_s prev_unsafe prev_safe_ns prev_safe_s*/ 230 0x0061, 0x0061, 0x0061, 0x0000, 0x0000, 0x0000, 231 0x10000, 0x10000, 0x10000, 0x120400, 0xdc00, UTF_ERROR_VALUE, 232 0xdc00, 0xdc00, UTF_ERROR_VALUE, 0x20441, 0x20441, 0x20441, 233 0x10ffff, 0x10ffff, 0x10ffff, 0xd841, 0xd841, UTF_ERROR_VALUE, 234 0xdfff, 0xdfff, UTF_ERROR_VALUE, 0xd7ff, 0xd7ff, 0xd7ff, 235 0x0062, 0x0062, 0x0062, 0xd841, 0xd841, UTF_ERROR_VALUE, 236 0x1ffff, 0xd841, UTF_ERROR_VALUE, 0x0062, 0x0062, 0x0062, 237 0xd7ff, 0xd7ff, 0xd7ff, 0x10ffff, 0x10ffff, 0x10ffff, 238 0x20441, 0x20441, 0x20441, 0xdbff, 0xdbff, UTF_ERROR_VALUE, 239 0xdc41, 0xdc41, UTF_ERROR_VALUE, 0x10000, 0x10000, 0x10000, 240 0xdc00, 0xdc00, UTF_ERROR_VALUE, 0xd800, 0xd800, UTF_ERROR_VALUE, 241 0x0000, 0x0000, 0x0000, 0x0061, 0x0061, 0x0061 242 }; 243 static uint16_t movedOffset[]={ 244 /*next_unsafe next_safe_ns next_safe_s prev_unsafe prev_safe_ns prev_safe_s*/ 245 1, 1, 1, 11, 11, 11, 246 3, 3, 3, 9, 10 , 10, 247 3, 3, 3, 8, 8, 8, 248 5, 5, 4, 8, 8, 8, 249 5, 5, 5, 7, 7, 7, 250 6, 6, 6, 6, 6, 6, 251 8, 7, 7, 5, 5, 5, 252 8, 8, 8, 3, 3, 3, 253 10, 10, 10, 3, 3, 3, 254 10, 10, 10, 1, 1, 1, 255 11, 11, 11, 1, 1, 1, 256 12, 12, 12, 0, 0, 0, 257 }; 258 259 260 UChar32 c=0x0000, expected; 261 uint16_t i=0; 262 uint16_t offset=0, setOffset=0; 263 for(offset=0; offset<UPRV_LENGTHOF(input); offset++){ 264 setOffset=offset; 265 #if !U_HIDE_OBSOLETE_UTF_OLD_H 266 UTF16_NEXT_CHAR_UNSAFE(input, setOffset, c); 267 if(setOffset != movedOffset[i]){ 268 log_err("ERROR: UTF16_NEXT_CHAR_UNSAFE failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n", 269 offset, movedOffset[i], setOffset); 270 } 271 if(c != result[i]){ 272 log_err("ERROR: UTF16_NEXT_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i], c); 273 } 274 #endif 275 setOffset=offset; 276 U16_NEXT_UNSAFE(input, setOffset, c); 277 if(setOffset != movedOffset[i]){ 278 log_err("ERROR: U16_NEXT_CHAR_UNSAFE failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n", 279 offset, movedOffset[i], setOffset); 280 } 281 if(c != result[i]){ 282 log_err("ERROR: U16_NEXT_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i], c); 283 } 284 expected=result[i+1]; 285 #if !U_HIDE_OBSOLETE_UTF_OLD_H 286 setOffset=offset; 287 UTF16_NEXT_CHAR_SAFE(input, setOffset, UPRV_LENGTHOF(input), c, FALSE); 288 if(setOffset != movedOffset[i+1]){ 289 log_err("ERROR: UTF16_NEXT_CHAR_SAFE failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n", 290 offset, movedOffset[i+1], setOffset); 291 } 292 if(c != expected) { 293 log_err("ERROR: UTF16_NEXT_CHAR_SAFE failed for input=%ld. Expected:%lx Got:%lx\n", offset, expected, c); 294 } 295 #endif 296 setOffset=offset; 297 U16_NEXT(input, setOffset, UPRV_LENGTHOF(input), c); 298 if(setOffset != movedOffset[i+1]){ 299 log_err("ERROR: U16_NEXT failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n", 300 offset, movedOffset[i+1], setOffset); 301 } 302 if(c != expected){ 303 log_err("ERROR: U16_NEXT failed for input=%ld. Expected:%lx Got:%lx\n", offset, expected, c); 304 } 305 306 setOffset=offset; 307 U16_NEXT_OR_FFFD(input, setOffset, UPRV_LENGTHOF(input), c); 308 if(setOffset != movedOffset[i+1]){ 309 log_err("ERROR: U16_NEXT_OR_FFFD failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n", 310 offset, movedOffset[i+1], setOffset); 311 } 312 if(U_IS_SURROGATE(expected)) { expected=0xfffd; } 313 if(c != expected){ 314 log_err("ERROR: U16_NEXT_OR_FFFD failed for input=%ld. Expected:%lx Got:%lx\n", offset, expected, c); 315 } 316 #if !U_HIDE_OBSOLETE_UTF_OLD_H 317 setOffset=offset; 318 UTF16_NEXT_CHAR_SAFE(input, setOffset, UPRV_LENGTHOF(input), c, TRUE); 319 if(setOffset != movedOffset[i+1]){ 320 log_err("ERROR: UTF16_NEXT_CHAR_SAFE(strict) failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n", 321 offset, movedOffset[i+2], setOffset); 322 } 323 if(c != result[i+2]){ 324 log_err("ERROR: UTF16_NEXT_CHAR_SAFE(strict) failed for input=%ld. Expected:%lx Got:%lx\n", offset, result[i+2], c); 325 } 326 #endif 327 i=(uint16_t)(i+6); 328 } 329 i=0; 330 for(offset=(uint16_t)UPRV_LENGTHOF(input); offset > 0; --offset){ 331 setOffset=offset; 332 #if !U_HIDE_OBSOLETE_UTF_OLD_H 333 UTF16_PREV_CHAR_UNSAFE(input, setOffset, c); 334 if(setOffset != movedOffset[i+3]){ 335 log_err("ERROR: UTF16_PREV_CHAR_UNSAFE failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n", 336 offset, movedOffset[i+3], setOffset); 337 } 338 if(c != result[i+3]){ 339 log_err("ERROR: UTF16_PREV_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+3], c); 340 } 341 #endif 342 setOffset=offset; 343 U16_PREV_UNSAFE(input, setOffset, c); 344 if(setOffset != movedOffset[i+3]){ 345 log_err("ERROR: U16_PREV_CHAR_UNSAFE failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n", 346 offset, movedOffset[i+3], setOffset); 347 } 348 if(c != result[i+3]){ 349 log_err("ERROR: U16_PREV_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+3], c); 350 } 351 #if !U_HIDE_OBSOLETE_UTF_OLD_H 352 setOffset=offset; 353 UTF16_PREV_CHAR_SAFE(input, 0, setOffset, c, FALSE); 354 if(setOffset != movedOffset[i+4]){ 355 log_err("ERROR: UTF16_PREV_CHAR_SAFE failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n", 356 offset, movedOffset[i+4], setOffset); 357 } 358 if(c != result[i+4]){ 359 log_err("ERROR: UTF16_PREV_CHAR_SAFE failed for input=%ld. Expected:%lx Got:%lx\n", offset, result[i+4], c); 360 } 361 #endif 362 setOffset=offset; 363 U16_PREV(input, 0, setOffset, c); 364 if(setOffset != movedOffset[i+4]){ 365 log_err("ERROR: U16_PREV failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n", 366 offset, movedOffset[i+4], setOffset); 367 } 368 expected = result[i+4]; 369 if(c != expected) { 370 log_err("ERROR: U16_PREV failed for input=%ld. Expected:%lx Got:%lx\n", offset, expected, c); 371 } 372 373 setOffset=offset; 374 U16_PREV_OR_FFFD(input, 0, setOffset, c); 375 if(setOffset != movedOffset[i+4]){ 376 log_err("ERROR: U16_PREV_OR_FFFD failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n", 377 offset, movedOffset[i+4], setOffset); 378 } 379 if(U_IS_SURROGATE(expected)) { expected=0xfffd; } 380 if(c != expected) { 381 log_err("ERROR: U16_PREV_OR_FFFD failed for input=%ld. Expected:%lx Got:%lx\n", offset, expected, c); 382 } 383 #if !U_HIDE_OBSOLETE_UTF_OLD_H 384 setOffset=offset; 385 UTF16_PREV_CHAR_SAFE(input, 0, setOffset, c, TRUE); 386 if(setOffset != movedOffset[i+5]){ 387 log_err("ERROR: UTF16_PREV_CHAR_SAFE(strict) failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n", 388 offset, movedOffset[i+5], setOffset); 389 } 390 if(c != result[i+5]){ 391 log_err("ERROR: UTF16_PREV_CHAR_SAFE(strict) failed for input=%ld. Expected:%lx Got:%lx\n", offset, result[i+5], c); 392 } 393 #endif 394 i=(uint16_t)(i+6); 395 } 396 397 } 398 399 /* keep this in sync with utf8tst.c's TestNulTerminated() */ 400 static void TestNulTerminated() { 401 static const UChar input[]={ 402 /* 0 */ 0x61, 403 /* 1 */ 0xd801, 0xdc01, 404 /* 3 */ 0xdc01, 405 /* 4 */ 0x62, 406 /* 5 */ 0xd801, 407 /* 6 */ 0x00 408 /* 7 */ 409 }; 410 static const UChar32 result[]={ 411 0x61, 412 0x10401, 413 0xdc01, 414 0x62, 415 0xd801, 416 0 417 }; 418 419 UChar32 c, c2, expected; 420 int32_t i0, i=0, j, k, expectedIndex; 421 int32_t cpIndex=0; 422 do { 423 i0=i; 424 U16_NEXT(input, i, -1, c); 425 expected=result[cpIndex]; 426 if(c!=expected) { 427 log_err("U16_NEXT(from %d)=U+%04x != U+%04x\n", i0, c, expected); 428 } 429 j=i0; 430 U16_NEXT_OR_FFFD(input, j, -1, c); 431 if(U_IS_SURROGATE(expected)) { expected=0xfffd; } 432 if(c!=expected) { 433 log_err("U16_NEXT_OR_FFFD(from %d)=U+%04x != U+%04x\n", i0, c, expected); 434 } 435 if(j!=i) { 436 log_err("U16_NEXT_OR_FFFD() moved to index %d but U16_NEXT() moved to %d\n", j, i); 437 } 438 j=i0; 439 U16_FWD_1(input, j, -1); 440 if(j!=i) { 441 log_err("U16_FWD_1() moved to index %d but U16_NEXT() moved to %d\n", j, i); 442 } 443 ++cpIndex; 444 /* 445 * Move by this many code points from the start. 446 * U16_FWD_N() stops at the end of the string, that is, at the NUL if necessary. 447 */ 448 expectedIndex= (c==0) ? i-1 : i; 449 k=0; 450 U16_FWD_N(input, k, -1, cpIndex); 451 if(k!=expectedIndex) { 452 log_err("U16_FWD_N(code points from 0) moved to index %d but expected %d\n", k, expectedIndex); 453 } 454 } while(c!=0); 455 456 i=0; 457 do { 458 j=i0=i; 459 U16_NEXT(input, i, -1, c); 460 do { 461 U16_GET(input, 0, j, -1, c2); 462 if(c2!=c) { 463 log_err("U16_NEXT(from %d)=U+%04x != U+%04x=U16_GET(at %d)\n", i0, c, c2, j); 464 } 465 U16_GET_OR_FFFD(input, 0, j, -1, c2); 466 expected= U_IS_SURROGATE(c) ? 0xfffd : c; 467 if(c2!=expected) { 468 log_err("U16_NEXT_OR_FFFD(from %d)=U+%04x != U+%04x=U16_GET_OR_FFFD(at %d)\n", i0, expected, c2, j); 469 } 470 /* U16_SET_CP_LIMIT moves from a non-lead byte to the limit of the code point */ 471 k=j+1; 472 U16_SET_CP_LIMIT(input, 0, k, -1); 473 if(k!=i) { 474 log_err("U16_NEXT() moved to %d but U16_SET_CP_LIMIT(%d) moved to %d\n", i, j+1, k); 475 } 476 } while(++j<i); 477 } while(c!=0); 478 } 479 480 static void TestFwdBack(){ 481 static UChar input[]={0x0061, 0xd800, 0xdc00, 0xdbff, 0xdfff, 0x0062, 0xd841, 0xd7ff, 0xd841, 0xdc41, 0xdc00, 0x0000}; 482 static uint16_t fwd_unsafe[] ={1, 3, 5, 6, 8, 10, 11, 12}; 483 static uint16_t fwd_safe[] ={1, 3, 5, 6, 7, 8, 10, 11, 12}; 484 static uint16_t back_unsafe[]={11, 9, 8, 7, 6, 5, 3, 1, 0}; 485 static uint16_t back_safe[] ={11, 10, 8, 7, 6, 5, 3, 1, 0}; 486 487 static uint16_t Nvalue[]= {0, 1, 2, 3, 1, 2, 1}; 488 static uint16_t fwd_N_unsafe[] ={0, 1, 5, 10, 11}; 489 static uint16_t fwd_N_safe[] ={0, 1, 5, 8, 10, 12, 12}; /*safe macro keeps it at the end of the string */ 490 static uint16_t back_N_unsafe[]={12, 11, 8, 5, 3}; 491 static uint16_t back_N_safe[] ={12, 11, 8, 5, 3, 0, 0}; 492 493 uint16_t offunsafe=0, offsafe=0; 494 uint16_t i=0; 495 #if !U_HIDE_OBSOLETE_UTF_OLD_H 496 while(offunsafe < UPRV_LENGTHOF(input)){ 497 UTF16_FWD_1_UNSAFE(input, offunsafe); 498 if(offunsafe != fwd_unsafe[i]){ 499 log_err("ERROR: Forward_unsafe offset expected:%d, Got:%d\n", fwd_unsafe[i], offunsafe); 500 } 501 i++; 502 } 503 #endif 504 offunsafe=0, offsafe=0; 505 i=0; 506 while(offunsafe < UPRV_LENGTHOF(input)){ 507 U16_FWD_1_UNSAFE(input, offunsafe); 508 if(offunsafe != fwd_unsafe[i]){ 509 log_err("ERROR: U16_FWD_1_UNSAFE offset expected:%d, Got:%d\n", fwd_unsafe[i], offunsafe); 510 } 511 i++; 512 } 513 #if !U_HIDE_OBSOLETE_UTF_OLD_H 514 offunsafe=0, offsafe=0; 515 i=0; 516 while(offsafe < UPRV_LENGTHOF(input)){ 517 UTF16_FWD_1_SAFE(input, offsafe, UPRV_LENGTHOF(input)); 518 if(offsafe != fwd_safe[i]){ 519 log_err("ERROR: Forward_safe offset expected:%d, Got:%d\n", fwd_safe[i], offsafe); 520 } 521 i++; 522 } 523 #endif 524 offunsafe=0, offsafe=0; 525 i=0; 526 while(offsafe < UPRV_LENGTHOF(input)){ 527 U16_FWD_1(input, offsafe, UPRV_LENGTHOF(input)); 528 if(offsafe != fwd_safe[i]){ 529 log_err("ERROR: U16_FWD_1 offset expected:%d, Got:%d\n", fwd_safe[i], offsafe); 530 } 531 i++; 532 } 533 #if !U_HIDE_OBSOLETE_UTF_OLD_H 534 offunsafe=UPRV_LENGTHOF(input); 535 offsafe=UPRV_LENGTHOF(input); 536 i=0; 537 while(offunsafe > 0){ 538 UTF16_BACK_1_UNSAFE(input, offunsafe); 539 if(offunsafe != back_unsafe[i]){ 540 log_err("ERROR: Backward_unsafe offset expected:%d, Got:%d\n", back_unsafe[i], offunsafe); 541 } 542 i++; 543 } 544 #endif 545 offunsafe=UPRV_LENGTHOF(input); 546 offsafe=UPRV_LENGTHOF(input); 547 i=0; 548 while(offunsafe > 0){ 549 U16_BACK_1_UNSAFE(input, offunsafe); 550 if(offunsafe != back_unsafe[i]){ 551 log_err("ERROR: U16_BACK_1_UNSAFE offset expected:%d, Got:%d\n", back_unsafe[i], offunsafe); 552 } 553 i++; 554 } 555 #if !U_HIDE_OBSOLETE_UTF_OLD_H 556 offunsafe=UPRV_LENGTHOF(input); 557 offsafe=UPRV_LENGTHOF(input); 558 i=0; 559 while(offsafe > 0){ 560 UTF16_BACK_1_SAFE(input,0, offsafe); 561 if(offsafe != back_safe[i]){ 562 log_err("ERROR: Backward_safe offset expected:%d, Got:%d\n", back_unsafe[i], offsafe); 563 } 564 i++; 565 } 566 #endif 567 offunsafe=UPRV_LENGTHOF(input); 568 offsafe=UPRV_LENGTHOF(input); 569 i=0; 570 while(offsafe > 0){ 571 U16_BACK_1(input,0, offsafe); 572 if(offsafe != back_safe[i]){ 573 log_err("ERROR: U16_BACK_1 offset expected:%d, Got:%d\n", back_unsafe[i], offsafe); 574 } 575 i++; 576 } 577 578 offunsafe=0; 579 offsafe=0; 580 #if !U_HIDE_OBSOLETE_UTF_OLD_H 581 for(i=0; i<UPRV_LENGTHOF(Nvalue)-2; i++){ /*didn't want it to fail(we assume 0<i<length)*/ 582 UTF16_FWD_N_UNSAFE(input, offunsafe, Nvalue[i]); 583 if(offunsafe != fwd_N_unsafe[i]){ 584 log_err("ERROR: Forward_N_unsafe offset expected:%d, Got:%d\n", fwd_N_unsafe[i], offunsafe); 585 } 586 } 587 #endif 588 offunsafe=0; 589 for(i=0; i<UPRV_LENGTHOF(Nvalue)-2; i++){ /*didn't want it to fail(we assume 0<i<length)*/ 590 U16_FWD_N_UNSAFE(input, offunsafe, Nvalue[i]); 591 if(offunsafe != fwd_N_unsafe[i]){ 592 log_err("ERROR: U16_FWD_N_UNSAFE offset expected:%d, Got:%d\n", fwd_N_unsafe[i], offunsafe); 593 } 594 } 595 #if !U_HIDE_OBSOLETE_UTF_OLD_H 596 offsafe=0; 597 for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){ 598 UTF16_FWD_N_SAFE(input, offsafe, UPRV_LENGTHOF(input), Nvalue[i]); 599 if(offsafe != fwd_N_safe[i]){ 600 log_err("ERROR: Forward_N_safe offset expected:%d, Got:%d\n", fwd_N_safe[i], offsafe); 601 } 602 } 603 #endif 604 offsafe=0; 605 for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){ 606 U16_FWD_N(input, offsafe, UPRV_LENGTHOF(input), Nvalue[i]); 607 if(offsafe != fwd_N_safe[i]){ 608 log_err("ERROR: U16_FWD_N offset expected:%d, Got:%d\n", fwd_N_safe[i], offsafe); 609 } 610 } 611 #if !U_HIDE_OBSOLETE_UTF_OLD_H 612 offunsafe=UPRV_LENGTHOF(input); 613 for(i=0; i<UPRV_LENGTHOF(Nvalue)-2; i++){ 614 UTF16_BACK_N_UNSAFE(input, offunsafe, Nvalue[i]); 615 if(offunsafe != back_N_unsafe[i]){ 616 log_err("ERROR: backward_N_unsafe offset expected:%d, Got:%d\n", back_N_unsafe[i], offunsafe); 617 } 618 } 619 #endif 620 offunsafe=UPRV_LENGTHOF(input); 621 for(i=0; i<UPRV_LENGTHOF(Nvalue)-2; i++){ 622 U16_BACK_N_UNSAFE(input, offunsafe, Nvalue[i]); 623 if(offunsafe != back_N_unsafe[i]){ 624 log_err("ERROR: U16_BACK_N_UNSAFE offset expected:%d, Got:%d\n", back_N_unsafe[i], offunsafe); 625 } 626 } 627 #if !U_HIDE_OBSOLETE_UTF_OLD_H 628 offsafe=UPRV_LENGTHOF(input); 629 for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){ 630 UTF16_BACK_N_SAFE(input, 0, offsafe, Nvalue[i]); 631 if(offsafe != back_N_safe[i]){ 632 log_err("ERROR: backward_N_safe offset expected:%d, Got:%d\n", back_N_safe[i], offsafe); 633 } 634 } 635 #endif 636 offsafe=UPRV_LENGTHOF(input); 637 for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){ 638 U16_BACK_N(input, 0, offsafe, Nvalue[i]); 639 if(offsafe != back_N_safe[i]){ 640 log_err("ERROR: U16_BACK_N offset expected:%d, Got:%d\n", back_N_safe[i], offsafe); 641 } 642 } 643 } 644 645 static void TestSetChar(){ 646 static UChar input[]={0x0061, 0xd800, 0xdc00, 0xdbff, 0xdfff, 0x0062, 0xd841, 0xd7ff, 0xd841, 0xdc41, 0xdc00, 0x0000}; 647 static uint16_t start_unsafe[]={0, 1, 1, 3, 3, 5, 6, 7, 8, 8, 9, 11}; 648 static uint16_t start_safe[] ={0, 1, 1, 3, 3, 5, 6, 7, 8, 8, 10, 11}; 649 static uint16_t limit_unsafe[]={0, 1, 3, 3, 5, 5, 6, 8, 8, 10, 10, 11}; 650 static uint16_t limit_safe[] ={0, 1, 3, 3, 5, 5, 6, 7, 8, 10, 10, 11}; 651 652 uint16_t i=0; 653 uint16_t offset=0, setOffset=0; 654 for(offset=0; offset<UPRV_LENGTHOF(input); offset++){ 655 #if !U_HIDE_OBSOLETE_UTF_OLD_H 656 setOffset=offset; 657 UTF16_SET_CHAR_START_UNSAFE(input, setOffset); 658 if(setOffset != start_unsafe[i]){ 659 log_err("ERROR: UTF16_SET_CHAR_START_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, start_unsafe[i], setOffset); 660 } 661 #endif 662 setOffset=offset; 663 U16_SET_CP_START_UNSAFE(input, setOffset); 664 if(setOffset != start_unsafe[i]){ 665 log_err("ERROR: U16_SET_CHAR_START_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, start_unsafe[i], setOffset); 666 } 667 #if !U_HIDE_OBSOLETE_UTF_OLD_H 668 setOffset=offset; 669 UTF16_SET_CHAR_START_SAFE(input, 0, setOffset); 670 if(setOffset != start_safe[i]){ 671 log_err("ERROR: UTF16_SET_CHAR_START_SAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, start_safe[i], setOffset); 672 } 673 #endif 674 setOffset=offset; 675 U16_SET_CP_START(input, 0, setOffset); 676 if(setOffset != start_safe[i]){ 677 log_err("ERROR: U16_SET_CHAR_START failed for offset=%ld. Expected:%lx Got:%lx\n", offset, start_safe[i], setOffset); 678 } 679 680 if (offset > 0) { 681 #if !U_HIDE_OBSOLETE_UTF_OLD_H 682 setOffset=offset; 683 UTF16_SET_CHAR_LIMIT_UNSAFE(input, setOffset); 684 if(setOffset != limit_unsafe[i]){ 685 log_err("ERROR: UTF16_SET_CHAR_LIMIT_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, limit_unsafe[i], setOffset); 686 } 687 #endif 688 setOffset=offset; 689 U16_SET_CP_LIMIT_UNSAFE(input, setOffset); 690 if(setOffset != limit_unsafe[i]){ 691 log_err("ERROR: U16_SET_CHAR_LIMIT_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, limit_unsafe[i], setOffset); 692 } 693 } 694 695 setOffset=offset; 696 U16_SET_CP_LIMIT(input,0, setOffset, UPRV_LENGTHOF(input)); 697 if(setOffset != limit_safe[i]){ 698 log_err("ERROR: U16_SET_CHAR_LIMIT failed for offset=%ld. Expected:%lx Got:%lx\n", offset, limit_safe[i], setOffset); 699 } 700 701 i++; 702 } 703 } 704 705 static void TestAppendChar(){ 706 #if !U_HIDE_OBSOLETE_UTF_OLD_H 707 static UChar s[5]={0x0061, 0x0062, 0x0063, 0x0064, 0x0000}; 708 static uint32_t test[]={ 709 /*append-position(unsafe), CHAR to be appended */ 710 0, 0x20441, 711 2, 0x0028, 712 2, 0xdc00, 713 3, 0xd800, 714 1, 0x20402, 715 716 /*append-position(safe), CHAR to be appended */ 717 0, 0x20441, 718 2, 0xdc00, 719 3, 0xd800, 720 1, 0x20402, 721 3, 0x20402, 722 3, 0x10402, 723 2, 0x10402, 724 725 }; 726 static uint16_t movedOffset[]={ 727 /*offset-moved-to(unsafe)*/ 728 2, /*for append-pos: 0 , CHAR 0x20441*/ 729 3, 730 3, 731 4, 732 3, 733 /*offse-moved-to(safe)*/ 734 2, /*for append-pos: 0, CHAR 0x20441*/ 735 3, 736 4, 737 3, 738 4, 739 4, 740 4 741 }; 742 743 static UChar result[][5]={ 744 /*unsafe*/ 745 {0xd841, 0xdc41, 0x0063, 0x0064, 0x0000}, 746 {0x0061, 0x0062, 0x0028, 0x0064, 0x0000}, 747 {0x0061, 0x0062, 0xdc00, 0x0064, 0x0000}, 748 {0x0061, 0x0062, 0x0063, 0xd800, 0x0000}, 749 {0x0061, 0xd841, 0xdc02, 0x0064, 0x0000}, 750 751 /*safe*/ 752 {0xd841, 0xdc41, 0x0063, 0x0064, 0x0000}, 753 {0x0061, 0x0062, 0xdc00, 0x0064, 0x0000}, 754 {0x0061, 0x0062, 0x0063, 0xd800, 0x0000}, 755 {0x0061, 0xd841, 0xdc02, 0x0064, 0x0000}, 756 {0x0061, 0x0062, 0x0063, UTF_ERROR_VALUE, 0x0000}, 757 {0x0061, 0x0062, 0x0063, UTF_ERROR_VALUE, 0x0000}, 758 {0x0061, 0x0062, 0xd801, 0xdc02, 0x0000}, 759 760 761 }; 762 uint16_t i, count=0; 763 UChar *str=(UChar*)malloc(sizeof(UChar) * (u_strlen(s)+1)); 764 uint16_t offset; 765 for(i=0; i<UPRV_LENGTHOF(test); i=(uint16_t)(i+2)){ 766 if(count<5){ 767 u_strcpy(str, s); 768 offset=(uint16_t)test[i]; 769 UTF16_APPEND_CHAR_UNSAFE(str, offset, test[i+1]); 770 if(offset != movedOffset[count]){ 771 log_err("ERROR: UTF16_APPEND_CHAR_UNSAFE failed to move the offset correctly for count=%d.\nExpectedOffset=%d currentOffset=%d\n", 772 count, movedOffset[count], offset); 773 774 } 775 if(u_strcmp(str, result[count]) !=0){ 776 log_err("ERROR: UTF16_APPEND_CHAR_UNSAFE failed for count=%d. Expected:", count); 777 printUChars(result[count]); 778 printf("\nGot:"); 779 printUChars(str); 780 printf("\n"); 781 } 782 }else{ 783 u_strcpy(str, s); 784 offset=(uint16_t)test[i]; 785 UTF16_APPEND_CHAR_SAFE(str, offset, (uint16_t)u_strlen(str), test[i+1]); 786 if(offset != movedOffset[count]){ 787 log_err("ERROR: UTF16_APPEND_CHAR_SAFE failed to move the offset correctly for count=%d.\nExpectedOffset=%d currentOffset=%d\n", 788 count, movedOffset[count], offset); 789 790 } 791 if(u_strcmp(str, result[count]) !=0){ 792 log_err("ERROR: UTF16_APPEND_CHAR_SAFE failed for count=%d. Expected:", count); 793 printUChars(result[count]); 794 printf("\nGot:"); 795 printUChars(str); 796 printf("\n"); 797 } 798 } 799 count++; 800 } 801 free(str); 802 #endif 803 } 804 805 static void TestAppend() { 806 static const UChar32 codePoints[]={ 807 0x61, 0xdf, 0x901, 0x3040, 808 0xac00, 0xd800, 0xdbff, 0xdcde, 809 0xdffd, 0xe000, 0xffff, 0x10000, 810 0x12345, 0xe0021, 0x10ffff, 0x110000, 811 0x234567, 0x7fffffff, -1, -1000, 812 0, 0x400 813 }; 814 static const UChar expectUnsafe[]={ 815 0x61, 0xdf, 0x901, 0x3040, 816 0xac00, 0xd800, 0xdbff, 0xdcde, 817 0xdffd, 0xe000, 0xffff, 0xd800, 0xdc00, 818 0xd808, 0xdf45, 0xdb40, 0xdc21, 0xdbff, 0xdfff, /* not 0x110000 */ 819 /* none from this line */ 820 0, 0x400 821 }, expectSafe[]={ 822 0x61, 0xdf, 0x901, 0x3040, 823 0xac00, 0xd800, 0xdbff, 0xdcde, 824 0xdffd, 0xe000, 0xffff, 0xd800, 0xdc00, 825 0xd808, 0xdf45, 0xdb40, 0xdc21, 0xdbff, 0xdfff, /* not 0x110000 */ 826 /* none from this line */ 827 0, 0x400 828 }; 829 830 UChar buffer[100]; 831 UChar32 c; 832 int32_t i, length; 833 UBool isError, expectIsError, wrongIsError; 834 835 length=0; 836 for(i=0; i<UPRV_LENGTHOF(codePoints); ++i) { 837 c=codePoints[i]; 838 if(c<0 || 0x10ffff<c) { 839 continue; /* skip non-code points for U16_APPEND_UNSAFE */ 840 } 841 842 U16_APPEND_UNSAFE(buffer, length, c); 843 } 844 if(length!=UPRV_LENGTHOF(expectUnsafe) || 0!=memcmp(buffer, expectUnsafe, length*U_SIZEOF_UCHAR)) { 845 log_err("U16_APPEND_UNSAFE did not generate the expected output\n"); 846 } 847 848 length=0; 849 wrongIsError=FALSE; 850 for(i=0; i<UPRV_LENGTHOF(codePoints); ++i) { 851 c=codePoints[i]; 852 expectIsError= c<0 || 0x10ffff<c; /* || U_IS_SURROGATE(c); */ /* surrogates in UTF-32 shouldn't be used, but it's okay to pass them around internally. */ 853 isError=FALSE; 854 855 U16_APPEND(buffer, length, UPRV_LENGTHOF(buffer), c, isError); 856 wrongIsError|= isError!=expectIsError; 857 } 858 if(wrongIsError) { 859 log_err("U16_APPEND did not set isError correctly\n"); 860 } 861 if(length!=UPRV_LENGTHOF(expectSafe) || 0!=memcmp(buffer, expectSafe, length*U_SIZEOF_UCHAR)) { 862 log_err("U16_APPEND did not generate the expected output\n"); 863 } 864 } 865 866 static void TestSurrogate(){ 867 static UChar32 s[] = {0x10000, 0x10ffff, 0x50000, 0x100000, 0x1abcd}; 868 int i = 0; 869 while (i < 5) { 870 UChar first = U16_LEAD(s[i]); 871 UChar second = U16_TRAIL(s[i]); 872 /* algorithm from the Unicode consortium */ 873 UChar firstresult = (UChar)(((s[i] - 0x10000) / 0x400) + 0xD800); 874 UChar secondresult = (UChar)(((s[i] - 0x10000) % 0x400) + 0xDC00); 875 876 if ( 877 #if !U_HIDE_OBSOLETE_UTF_OLD_H 878 first != UTF16_LEAD(s[i]) || first != UTF_FIRST_SURROGATE(s[i]) || 879 #endif 880 first != firstresult) { 881 log_err("Failure in first surrogate in 0x%x expected to be 0x%x\n", 882 s[i], firstresult); 883 } 884 if ( 885 #if !U_HIDE_OBSOLETE_UTF_OLD_H 886 second != UTF16_TRAIL(s[i]) || second != UTF_SECOND_SURROGATE(s[i]) || 887 #endif 888 second != secondresult) { 889 log_err("Failure in second surrogate in 0x%x expected to be 0x%x\n", 890 s[i], secondresult); 891 } 892 i ++; 893 } 894 } 895
