1 // Copyright (C) 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ****************************************************************************** 5 * 6 * Copyright (C) 2002-2016, International Business Machines 7 * Corporation and others. All Rights Reserved. 8 * 9 ****************************************************************************** 10 * file name: custrtst.c 11 * encoding: US-ASCII 12 * tab size: 8 (not used) 13 * indentation:4 14 * 15 * created on: 2002oct09 16 * created by: Markus W. Scherer 17 * 18 * Tests of ustring.h Unicode string API functions. 19 */ 20 21 #include "unicode/ustring.h" 22 #include "unicode/ucnv.h" 23 #include "unicode/uiter.h" 24 #include "cintltst.h" 25 #include "cmemory.h" 26 #include <string.h> 27 28 /* get the sign of an integer */ 29 #define _SIGN(value) ((value)==0 ? 0 : ((int32_t)(value)>>31)|1) 30 31 /* test setup --------------------------------------------------------------- */ 32 33 static void setUpDataTable(void); 34 static void TestStringCopy(void); 35 static void TestStringFunctions(void); 36 static void TestStringSearching(void); 37 static void TestSurrogateSearching(void); 38 static void TestUnescape(void); 39 static void TestCountChar32(void); 40 static void TestUCharIterator(void); 41 42 void addUStringTest(TestNode** root); 43 44 void addUStringTest(TestNode** root) 45 { 46 addTest(root, &TestStringCopy, "tsutil/custrtst/TestStringCopy"); 47 addTest(root, &TestStringFunctions, "tsutil/custrtst/TestStringFunctions"); 48 addTest(root, &TestStringSearching, "tsutil/custrtst/TestStringSearching"); 49 addTest(root, &TestSurrogateSearching, "tsutil/custrtst/TestSurrogateSearching"); 50 addTest(root, &TestUnescape, "tsutil/custrtst/TestUnescape"); 51 addTest(root, &TestCountChar32, "tsutil/custrtst/TestCountChar32"); 52 addTest(root, &TestUCharIterator, "tsutil/custrtst/TestUCharIterator"); 53 } 54 55 /* test data for TestStringFunctions ---------------------------------------- */ 56 57 UChar*** dataTable = NULL; 58 59 static const char* raw[3][4] = { 60 61 /* First String */ 62 { "English_", "French_", "Croatian_", "English_"}, 63 /* Second String */ 64 { "United States", "France", "Croatia", "Unites States"}, 65 66 /* Concatenated string */ 67 { "English_United States", "French_France", "Croatian_Croatia", "English_United States"} 68 }; 69 70 static void setUpDataTable() 71 { 72 int32_t i,j; 73 if(dataTable == NULL) { 74 dataTable = (UChar***)calloc(sizeof(UChar**),3); 75 76 for (i = 0; i < 3; i++) { 77 dataTable[i] = (UChar**)calloc(sizeof(UChar*),4); 78 for (j = 0; j < 4; j++){ 79 dataTable[i][j] = (UChar*) malloc(sizeof(UChar)*(strlen(raw[i][j])+1)); 80 u_uastrcpy(dataTable[i][j],raw[i][j]); 81 } 82 } 83 } 84 } 85 86 static void cleanUpDataTable() 87 { 88 int32_t i,j; 89 if(dataTable != NULL) { 90 for (i=0; i<3; i++) { 91 for(j = 0; j<4; j++) { 92 free(dataTable[i][j]); 93 } 94 free(dataTable[i]); 95 } 96 free(dataTable); 97 } 98 dataTable = NULL; 99 } 100 101 /*Tests for u_strcat(),u_strcmp(), u_strlen(), u_strcpy(),u_strncat(),u_strncmp(),u_strncpy, u_uastrcpy(),u_austrcpy(), u_uastrncpy(); */ 102 static void TestStringFunctions() 103 { 104 int32_t i,j,k; 105 UChar temp[512]; 106 UChar nullTemp[512]; 107 char test[512]; 108 char tempOut[512]; 109 110 setUpDataTable(); 111 112 log_verbose("Testing u_strlen()\n"); 113 if( u_strlen(dataTable[0][0])!= u_strlen(dataTable[0][3]) || u_strlen(dataTable[0][0]) == u_strlen(dataTable[0][2])) 114 log_err("There is an error in u_strlen()"); 115 116 log_verbose("Testing u_memcpy() and u_memcmp()\n"); 117 118 for(i=0;i<3;++i) 119 { 120 for(j=0;j<4;++j) 121 { 122 log_verbose("Testing %s\n", u_austrcpy(tempOut, dataTable[i][j])); 123 temp[0] = 0; 124 temp[7] = 0xA4; /* Mark the end */ 125 u_memcpy(temp,dataTable[i][j], 7); 126 127 if(temp[7] != 0xA4) 128 log_err("an error occured in u_memcpy()\n"); 129 if(u_memcmp(temp, dataTable[i][j], 7)!=0) 130 log_err("an error occured in u_memcpy() or u_memcmp()\n"); 131 } 132 } 133 if(u_memcmp(dataTable[0][0], dataTable[1][1], 7)==0) 134 log_err("an error occured in u_memcmp()\n"); 135 136 log_verbose("Testing u_memset()\n"); 137 nullTemp[0] = 0; 138 nullTemp[7] = 0; 139 u_memset(nullTemp, 0xa4, 7); 140 for (i = 0; i < 7; i++) { 141 if(nullTemp[i] != 0xa4) { 142 log_err("an error occured in u_memset()\n"); 143 } 144 } 145 if(nullTemp[7] != 0) { 146 log_err("u_memset() went too far\n"); 147 } 148 149 u_memset(nullTemp, 0, 7); 150 nullTemp[7] = 0xa4; 151 temp[7] = 0; 152 u_memcpy(temp,nullTemp, 7); 153 if(u_memcmp(temp, nullTemp, 7)!=0 || temp[7]!=0) 154 log_err("an error occured in u_memcpy() or u_memcmp()\n"); 155 156 157 log_verbose("Testing u_memmove()\n"); 158 for (i = 0; i < 7; i++) { 159 temp[i] = (UChar)i; 160 } 161 u_memmove(temp + 1, temp, 7); 162 if(temp[0] != 0) { 163 log_err("an error occured in u_memmove()\n"); 164 } 165 for (i = 1; i <= 7; i++) { 166 if(temp[i] != (i - 1)) { 167 log_err("an error occured in u_memmove()\n"); 168 } 169 } 170 171 log_verbose("Testing u_strcpy() and u_strcmp()\n"); 172 173 for(i=0;i<3;++i) 174 { 175 for(j=0;j<4;++j) 176 { 177 log_verbose("Testing %s\n", u_austrcpy(tempOut, dataTable[i][j])); 178 temp[0] = 0; 179 u_strcpy(temp,dataTable[i][j]); 180 181 if(u_strcmp(temp,dataTable[i][j])!=0) 182 log_err("something threw an error in u_strcpy() or u_strcmp()\n"); 183 } 184 } 185 if(u_strcmp(dataTable[0][0], dataTable[1][1])==0) 186 log_err("an error occured in u_memcmp()\n"); 187 188 log_verbose("testing u_strcat()\n"); 189 i=0; 190 for(j=0; j<2;++j) 191 { 192 u_uastrcpy(temp, ""); 193 u_strcpy(temp,dataTable[i][j]); 194 u_strcat(temp,dataTable[i+1][j]); 195 if(u_strcmp(temp,dataTable[i+2][j])!=0) 196 log_err("something threw an error in u_strcat()\n"); 197 198 } 199 log_verbose("Testing u_strncmp()\n"); 200 for(i=0,j=0;j<4; ++j) 201 { 202 k=u_strlen(dataTable[i][j]); 203 if(u_strncmp(dataTable[i][j],dataTable[i+2][j],k)!=0) 204 log_err("Something threw an error in u_strncmp\n"); 205 } 206 if(u_strncmp(dataTable[0][0], dataTable[1][1], 7)==0) 207 log_err("an error occured in u_memcmp()\n"); 208 209 210 log_verbose("Testing u_strncat\n"); 211 for(i=0,j=0;j<4; ++j) 212 { 213 k=u_strlen(dataTable[i][j]); 214 215 u_uastrcpy(temp,""); 216 217 if(u_strcmp(u_strncat(temp,dataTable[i+2][j],k),dataTable[i][j])!=0) 218 log_err("something threw an error in u_strncat or u_uastrcpy()\n"); 219 220 } 221 222 log_verbose("Testing u_strncpy() and u_uastrcpy()\n"); 223 for(i=2,j=0;j<4; ++j) 224 { 225 k=u_strlen(dataTable[i][j]); 226 u_strncpy(temp, dataTable[i][j],k); 227 temp[k] = 0xa4; 228 229 if(u_strncmp(temp, dataTable[i][j],k)!=0) 230 log_err("something threw an error in u_strncpy()\n"); 231 232 if(temp[k] != 0xa4) 233 log_err("something threw an error in u_strncpy()\n"); 234 235 u_memset(temp, 0x3F, UPRV_LENGTHOF(temp) - 1); 236 u_uastrncpy(temp, raw[i][j], k-1); 237 if(u_strncmp(temp, dataTable[i][j],k-1)!=0) 238 log_err("something threw an error in u_uastrncpy(k-1)\n"); 239 240 if(temp[k-1] != 0x3F) 241 log_err("something threw an error in u_uastrncpy(k-1)\n"); 242 243 u_memset(temp, 0x3F, UPRV_LENGTHOF(temp) - 1); 244 u_uastrncpy(temp, raw[i][j], k+1); 245 if(u_strcmp(temp, dataTable[i][j])!=0) 246 log_err("something threw an error in u_uastrncpy(k+1)\n"); 247 248 if(temp[k] != 0) 249 log_err("something threw an error in u_uastrncpy(k+1)\n"); 250 251 u_memset(temp, 0x3F, UPRV_LENGTHOF(temp) - 1); 252 u_uastrncpy(temp, raw[i][j], k); 253 if(u_strncmp(temp, dataTable[i][j], k)!=0) 254 log_err("something threw an error in u_uastrncpy(k)\n"); 255 256 if(temp[k] != 0x3F) 257 log_err("something threw an error in u_uastrncpy(k)\n"); 258 } 259 260 log_verbose("Testing u_strchr() and u_memchr()\n"); 261 262 for(i=2,j=0;j<4;j++) 263 { 264 UChar saveVal = dataTable[i][j][0]; 265 UChar *findPtr = u_strchr(dataTable[i][j], 0x005F); 266 int32_t dataSize = (int32_t)(u_strlen(dataTable[i][j]) + 1); 267 268 log_verbose("%s ", u_austrcpy(tempOut, findPtr)); 269 270 if (findPtr == NULL || *findPtr != 0x005F) { 271 log_err("u_strchr can't find '_' in the string\n"); 272 } 273 274 findPtr = u_strchr32(dataTable[i][j], 0x005F); 275 if (findPtr == NULL || *findPtr != 0x005F) { 276 log_err("u_strchr32 can't find '_' in the string\n"); 277 } 278 279 findPtr = u_strchr(dataTable[i][j], 0); 280 if (findPtr != (&(dataTable[i][j][dataSize - 1]))) { 281 log_err("u_strchr can't find NULL in the string\n"); 282 } 283 284 findPtr = u_strchr32(dataTable[i][j], 0); 285 if (findPtr != (&(dataTable[i][j][dataSize - 1]))) { 286 log_err("u_strchr32 can't find NULL in the string\n"); 287 } 288 289 findPtr = u_memchr(dataTable[i][j], 0, dataSize); 290 if (findPtr != (&(dataTable[i][j][dataSize - 1]))) { 291 log_err("u_memchr can't find NULL in the string\n"); 292 } 293 294 findPtr = u_memchr32(dataTable[i][j], 0, dataSize); 295 if (findPtr != (&(dataTable[i][j][dataSize - 1]))) { 296 log_err("u_memchr32 can't find NULL in the string\n"); 297 } 298 299 dataTable[i][j][0] = 0; 300 /* Make sure we skip over the NULL termination */ 301 findPtr = u_memchr(dataTable[i][j], 0x005F, dataSize); 302 if (findPtr == NULL || *findPtr != 0x005F) { 303 log_err("u_memchr can't find '_' in the string\n"); 304 } 305 306 findPtr = u_memchr32(dataTable[i][j], 0x005F, dataSize); 307 if (findPtr == NULL || *findPtr != 0x005F) { 308 log_err("u_memchr32 can't find '_' in the string\n"); 309 } 310 findPtr = u_memchr32(dataTable[i][j], 0xFFFD, dataSize); 311 if (findPtr != NULL) { 312 log_err("Should have found NULL when the character is not there.\n"); 313 } 314 dataTable[i][j][0] = saveVal; /* Put it back for the other tests */ 315 } 316 317 /* 318 * test that u_strchr32() 319 * does not find surrogate code points when they are part of matched pairs 320 * (= part of supplementary code points) 321 * Jitterbug 1542 322 */ 323 { 324 static const UChar s[]={ 325 /* 0 1 2 3 4 5 6 7 8 9 */ 326 0x0061, 0xd841, 0xdc02, 0xd841, 0x0062, 0xdc02, 0xd841, 0xdc02, 0x0063, 0 327 }; 328 329 if(u_strchr32(s, 0xd841)!=(s+3) || u_strchr32(s, 0xdc02)!=(s+5)) { 330 log_err("error: u_strchr32(surrogate) finds a partial supplementary code point\n"); 331 } 332 if(u_memchr32(s, 0xd841, 9)!=(s+3) || u_memchr32(s, 0xdc02, 9)!=(s+5)) { 333 log_err("error: u_memchr32(surrogate) finds a partial supplementary code point\n"); 334 } 335 } 336 337 log_verbose("Testing u_austrcpy()"); 338 u_austrcpy(test,dataTable[0][0]); 339 if(strcmp(test,raw[0][0])!=0) 340 log_err("There is an error in u_austrcpy()"); 341 342 343 log_verbose("Testing u_strtok_r()"); 344 { 345 const char tokString[] = " , 1 2 3 AHHHHH! 5.5 6 7 , 8\n"; 346 const char *tokens[] = {",", "1", "2", "3", "AHHHHH!", "5.5", "6", "7", "8\n"}; 347 UChar delimBuf[sizeof(test)]; 348 UChar currTokenBuf[sizeof(tokString)]; 349 UChar *state; 350 uint32_t currToken = 0; 351 UChar *ptr; 352 353 u_uastrcpy(temp, tokString); 354 u_uastrcpy(delimBuf, " "); 355 356 ptr = u_strtok_r(temp, delimBuf, &state); 357 u_uastrcpy(delimBuf, " ,"); 358 while (ptr != NULL) { 359 u_uastrcpy(currTokenBuf, tokens[currToken]); 360 if (u_strcmp(ptr, currTokenBuf) != 0) { 361 log_err("u_strtok_r mismatch at %d. Got: %s, Expected: %s\n", currToken, ptr, tokens[currToken]); 362 } 363 ptr = u_strtok_r(NULL, delimBuf, &state); 364 currToken++; 365 } 366 367 if (currToken != UPRV_LENGTHOF(tokens)) { 368 log_err("Didn't get correct number of tokens\n"); 369 } 370 state = delimBuf; /* Give it an "invalid" saveState */ 371 u_uastrcpy(currTokenBuf, ""); 372 if (u_strtok_r(currTokenBuf, delimBuf, &state) != NULL) { 373 log_err("Didn't get NULL for empty string\n"); 374 } 375 if (state != NULL) { 376 log_err("State should be NULL for empty string\n"); 377 } 378 state = delimBuf; /* Give it an "invalid" saveState */ 379 u_uastrcpy(currTokenBuf, ", ,"); 380 if (u_strtok_r(currTokenBuf, delimBuf, &state) != NULL) { 381 log_err("Didn't get NULL for a string of delimiters\n"); 382 } 383 if (state != NULL) { 384 log_err("State should be NULL for a string of delimiters\n"); 385 } 386 387 state = delimBuf; /* Give it an "invalid" saveState */ 388 u_uastrcpy(currTokenBuf, "q, ,"); 389 if (u_strtok_r(currTokenBuf, delimBuf, &state) == NULL) { 390 log_err("Got NULL for a string that does not begin with delimiters\n"); 391 } 392 if (u_strtok_r(NULL, delimBuf, &state) != NULL) { 393 log_err("Didn't get NULL for a string that ends in delimiters\n"); 394 } 395 if (state != NULL) { 396 log_err("State should be NULL for empty string\n"); 397 } 398 399 state = delimBuf; /* Give it an "invalid" saveState */ 400 u_uastrcpy(currTokenBuf, tokString); 401 u_uastrcpy(temp, tokString); 402 u_uastrcpy(delimBuf, "q"); /* Give it a delimiter that it can't find. */ 403 ptr = u_strtok_r(currTokenBuf, delimBuf, &state); 404 if (ptr == NULL || u_strcmp(ptr, temp) != 0) { 405 log_err("Should have recieved the same string when there are no delimiters\n"); 406 } 407 if (u_strtok_r(NULL, delimBuf, &state) != NULL) { 408 log_err("Should not have found another token in a one token string\n"); 409 } 410 } 411 412 /* test u_strcmpCodePointOrder() */ 413 { 414 /* these strings are in ascending order */ 415 static const UChar strings[][4]={ 416 { 0x61, 0 }, /* U+0061 */ 417 { 0x20ac, 0xd801, 0 }, /* U+20ac U+d801 */ 418 { 0x20ac, 0xd800, 0xdc00, 0 }, /* U+20ac U+10000 */ 419 { 0xd800, 0 }, /* U+d800 */ 420 { 0xd800, 0xff61, 0 }, /* U+d800 U+ff61 */ 421 { 0xdfff, 0 }, /* U+dfff */ 422 { 0xff61, 0xdfff, 0 }, /* U+ff61 U+dfff */ 423 { 0xff61, 0xd800, 0xdc02, 0 }, /* U+ff61 U+10002 */ 424 { 0xd800, 0xdc02, 0 }, /* U+10002 */ 425 { 0xd84d, 0xdc56, 0 } /* U+23456 */ 426 }; 427 428 UCharIterator iter1, iter2; 429 int32_t len1, len2, r1, r2; 430 431 for(i=0; i<(UPRV_LENGTHOF(strings)-1); ++i) { 432 if(u_strcmpCodePointOrder(strings[i], strings[i+1])>=0) { 433 log_err("error: u_strcmpCodePointOrder() fails for string %d and the following one\n", i); 434 } 435 if(u_strncmpCodePointOrder(strings[i], strings[i+1], 10)>=0) { 436 log_err("error: u_strncmpCodePointOrder() fails for string %d and the following one\n", i); 437 } 438 439 /* There are at least 2 UChars in each string - verify that strncmp()==memcmp(). */ 440 if(u_strncmpCodePointOrder(strings[i], strings[i+1], 2)!=u_memcmpCodePointOrder(strings[i], strings[i+1], 2)) { 441 log_err("error: u_strncmpCodePointOrder(2)!=u_memcmpCodePointOrder(2) for string %d and the following one\n", i); 442 } 443 444 /* test u_strCompare(TRUE) */ 445 len1=u_strlen(strings[i]); 446 len2=u_strlen(strings[i+1]); 447 if( u_strCompare(strings[i], -1, strings[i+1], -1, TRUE)>=0 || 448 u_strCompare(strings[i], -1, strings[i+1], len2, TRUE)>=0 || 449 u_strCompare(strings[i], len1, strings[i+1], -1, TRUE)>=0 || 450 u_strCompare(strings[i], len1, strings[i+1], len2, TRUE)>=0 451 ) { 452 log_err("error: u_strCompare(code point order) fails for string %d and the following one\n", i); 453 } 454 455 /* test u_strCompare(FALSE) */ 456 r1=u_strCompare(strings[i], -1, strings[i+1], -1, FALSE); 457 r2=u_strcmp(strings[i], strings[i+1]); 458 if(_SIGN(r1)!=_SIGN(r2)) { 459 log_err("error: u_strCompare(code unit order)!=u_strcmp() for string %d and the following one\n", i); 460 } 461 462 /* test u_strCompareIter() */ 463 uiter_setString(&iter1, strings[i], len1); 464 uiter_setString(&iter2, strings[i+1], len2); 465 if(u_strCompareIter(&iter1, &iter2, TRUE)>=0) { 466 log_err("error: u_strCompareIter(code point order) fails for string %d and the following one\n", i); 467 } 468 r1=u_strCompareIter(&iter1, &iter2, FALSE); 469 if(_SIGN(r1)!=_SIGN(u_strcmp(strings[i], strings[i+1]))) { 470 log_err("error: u_strCompareIter(code unit order)!=u_strcmp() for string %d and the following one\n", i); 471 } 472 } 473 } 474 475 cleanUpDataTable(); 476 } 477 478 static void TestStringSearching() 479 { 480 const UChar testString[] = {0x0061, 0x0062, 0x0063, 0x0064, 0x0064, 0x0061, 0}; 481 const UChar testSurrogateString[] = {0xdbff, 0x0061, 0x0062, 0xdbff, 0xdfff, 0x0063, 0x0064, 0x0064, 0xdbff, 0xdfff, 0xdb00, 0xdf00, 0x0061, 0}; 482 const UChar surrMatchSet1[] = {0xdbff, 0xdfff, 0}; 483 const UChar surrMatchSet2[] = {0x0061, 0x0062, 0xdbff, 0xdfff, 0}; 484 const UChar surrMatchSet3[] = {0xdb00, 0xdf00, 0xdbff, 0xdfff, 0}; 485 const UChar surrMatchSet4[] = {0x0000}; 486 const UChar surrMatchSetBad[] = {0xdbff, 0x0061, 0}; 487 const UChar surrMatchSetBad2[] = {0x0061, 0xdbff, 0}; 488 const UChar surrMatchSetBad3[] = {0xdbff, 0x0061, 0x0062, 0xdbff, 0xdfff, 0}; /* has partial surrogate */ 489 const UChar 490 empty[] = { 0 }, 491 a[] = { 0x61, 0 }, 492 ab[] = { 0x61, 0x62, 0 }, 493 ba[] = { 0x62, 0x61, 0 }, 494 abcd[] = { 0x61, 0x62, 0x63, 0x64, 0 }, 495 cd[] = { 0x63, 0x64, 0 }, 496 dc[] = { 0x64, 0x63, 0 }, 497 cdh[] = { 0x63, 0x64, 0x68, 0 }, 498 f[] = { 0x66, 0 }, 499 fg[] = { 0x66, 0x67, 0 }, 500 gf[] = { 0x67, 0x66, 0 }; 501 502 log_verbose("Testing u_strpbrk()"); 503 504 if (u_strpbrk(testString, a) != &testString[0]) { 505 log_err("u_strpbrk couldn't find first letter a.\n"); 506 } 507 if (u_strpbrk(testString, dc) != &testString[2]) { 508 log_err("u_strpbrk couldn't find d or c.\n"); 509 } 510 if (u_strpbrk(testString, cd) != &testString[2]) { 511 log_err("u_strpbrk couldn't find c or d.\n"); 512 } 513 if (u_strpbrk(testString, cdh) != &testString[2]) { 514 log_err("u_strpbrk couldn't find c, d or h.\n"); 515 } 516 if (u_strpbrk(testString, f) != NULL) { 517 log_err("u_strpbrk didn't return NULL for \"f\".\n"); 518 } 519 if (u_strpbrk(testString, fg) != NULL) { 520 log_err("u_strpbrk didn't return NULL for \"fg\".\n"); 521 } 522 if (u_strpbrk(testString, gf) != NULL) { 523 log_err("u_strpbrk didn't return NULL for \"gf\".\n"); 524 } 525 if (u_strpbrk(testString, empty) != NULL) { 526 log_err("u_strpbrk didn't return NULL for \"\".\n"); 527 } 528 529 log_verbose("Testing u_strpbrk() with surrogates"); 530 531 if (u_strpbrk(testSurrogateString, a) != &testSurrogateString[1]) { 532 log_err("u_strpbrk couldn't find first letter a.\n"); 533 } 534 if (u_strpbrk(testSurrogateString, dc) != &testSurrogateString[5]) { 535 log_err("u_strpbrk couldn't find d or c.\n"); 536 } 537 if (u_strpbrk(testSurrogateString, cd) != &testSurrogateString[5]) { 538 log_err("u_strpbrk couldn't find c or d.\n"); 539 } 540 if (u_strpbrk(testSurrogateString, cdh) != &testSurrogateString[5]) { 541 log_err("u_strpbrk couldn't find c, d or h.\n"); 542 } 543 if (u_strpbrk(testSurrogateString, f) != NULL) { 544 log_err("u_strpbrk didn't return NULL for \"f\".\n"); 545 } 546 if (u_strpbrk(testSurrogateString, fg) != NULL) { 547 log_err("u_strpbrk didn't return NULL for \"fg\".\n"); 548 } 549 if (u_strpbrk(testSurrogateString, gf) != NULL) { 550 log_err("u_strpbrk didn't return NULL for \"gf\".\n"); 551 } 552 if (u_strpbrk(testSurrogateString, surrMatchSet1) != &testSurrogateString[3]) { 553 log_err("u_strpbrk couldn't find \"0xdbff, 0xdfff\".\n"); 554 } 555 if (u_strpbrk(testSurrogateString, surrMatchSet2) != &testSurrogateString[1]) { 556 log_err("u_strpbrk couldn't find \"0xdbff, a, b, 0xdbff, 0xdfff\".\n"); 557 } 558 if (u_strpbrk(testSurrogateString, surrMatchSet3) != &testSurrogateString[3]) { 559 log_err("u_strpbrk couldn't find \"0xdb00, 0xdf00, 0xdbff, 0xdfff\".\n"); 560 } 561 if (u_strpbrk(testSurrogateString, surrMatchSet4) != NULL) { 562 log_err("u_strpbrk should have returned NULL for empty string.\n"); 563 } 564 if (u_strpbrk(testSurrogateString, surrMatchSetBad) != &testSurrogateString[0]) { 565 log_err("u_strpbrk should have found bad surrogate.\n"); 566 } 567 568 log_verbose("Testing u_strcspn()"); 569 570 if (u_strcspn(testString, a) != 0) { 571 log_err("u_strcspn couldn't find first letter a.\n"); 572 } 573 if (u_strcspn(testString, dc) != 2) { 574 log_err("u_strcspn couldn't find d or c.\n"); 575 } 576 if (u_strcspn(testString, cd) != 2) { 577 log_err("u_strcspn couldn't find c or d.\n"); 578 } 579 if (u_strcspn(testString, cdh) != 2) { 580 log_err("u_strcspn couldn't find c, d or h.\n"); 581 } 582 if (u_strcspn(testString, f) != u_strlen(testString)) { 583 log_err("u_strcspn didn't return NULL for \"f\".\n"); 584 } 585 if (u_strcspn(testString, fg) != u_strlen(testString)) { 586 log_err("u_strcspn didn't return NULL for \"fg\".\n"); 587 } 588 if (u_strcspn(testString, gf) != u_strlen(testString)) { 589 log_err("u_strcspn didn't return NULL for \"gf\".\n"); 590 } 591 592 log_verbose("Testing u_strcspn() with surrogates"); 593 594 if (u_strcspn(testSurrogateString, a) != 1) { 595 log_err("u_strcspn couldn't find first letter a.\n"); 596 } 597 if (u_strcspn(testSurrogateString, dc) != 5) { 598 log_err("u_strcspn couldn't find d or c.\n"); 599 } 600 if (u_strcspn(testSurrogateString, cd) != 5) { 601 log_err("u_strcspn couldn't find c or d.\n"); 602 } 603 if (u_strcspn(testSurrogateString, cdh) != 5) { 604 log_err("u_strcspn couldn't find c, d or h.\n"); 605 } 606 if (u_strcspn(testSurrogateString, f) != u_strlen(testSurrogateString)) { 607 log_err("u_strcspn didn't return NULL for \"f\".\n"); 608 } 609 if (u_strcspn(testSurrogateString, fg) != u_strlen(testSurrogateString)) { 610 log_err("u_strcspn didn't return NULL for \"fg\".\n"); 611 } 612 if (u_strcspn(testSurrogateString, gf) != u_strlen(testSurrogateString)) { 613 log_err("u_strcspn didn't return NULL for \"gf\".\n"); 614 } 615 if (u_strcspn(testSurrogateString, surrMatchSet1) != 3) { 616 log_err("u_strcspn couldn't find \"0xdbff, 0xdfff\".\n"); 617 } 618 if (u_strcspn(testSurrogateString, surrMatchSet2) != 1) { 619 log_err("u_strcspn couldn't find \"a, b, 0xdbff, 0xdfff\".\n"); 620 } 621 if (u_strcspn(testSurrogateString, surrMatchSet3) != 3) { 622 log_err("u_strcspn couldn't find \"0xdb00, 0xdf00, 0xdbff, 0xdfff\".\n"); 623 } 624 if (u_strcspn(testSurrogateString, surrMatchSet4) != u_strlen(testSurrogateString)) { 625 log_err("u_strcspn should have returned strlen for empty string.\n"); 626 } 627 628 629 log_verbose("Testing u_strspn()"); 630 631 if (u_strspn(testString, a) != 1) { 632 log_err("u_strspn couldn't skip first letter a.\n"); 633 } 634 if (u_strspn(testString, ab) != 2) { 635 log_err("u_strspn couldn't skip a or b.\n"); 636 } 637 if (u_strspn(testString, ba) != 2) { 638 log_err("u_strspn couldn't skip a or b.\n"); 639 } 640 if (u_strspn(testString, f) != 0) { 641 log_err("u_strspn didn't return 0 for \"f\".\n"); 642 } 643 if (u_strspn(testString, dc) != 0) { 644 log_err("u_strspn couldn't find first letter a (skip d or c).\n"); 645 } 646 if (u_strspn(testString, abcd) != u_strlen(testString)) { 647 log_err("u_strspn couldn't skip over the whole string.\n"); 648 } 649 if (u_strspn(testString, empty) != 0) { 650 log_err("u_strspn should have returned 0 for empty string.\n"); 651 } 652 653 log_verbose("Testing u_strspn() with surrogates"); 654 if (u_strspn(testSurrogateString, surrMatchSetBad) != 2) { 655 log_err("u_strspn couldn't skip 0xdbff or a.\n"); 656 } 657 if (u_strspn(testSurrogateString, surrMatchSetBad2) != 2) { 658 log_err("u_strspn couldn't skip 0xdbff or a.\n"); 659 } 660 if (u_strspn(testSurrogateString, f) != 0) { 661 log_err("u_strspn couldn't skip d or c (skip first letter).\n"); 662 } 663 if (u_strspn(testSurrogateString, dc) != 0) { 664 log_err("u_strspn couldn't skip d or c (skip first letter).\n"); 665 } 666 if (u_strspn(testSurrogateString, cd) != 0) { 667 log_err("u_strspn couldn't skip d or c (skip first letter).\n"); 668 } 669 if (u_strspn(testSurrogateString, testSurrogateString) != u_strlen(testSurrogateString)) { 670 log_err("u_strspn couldn't skip whole string.\n"); 671 } 672 if (u_strspn(testSurrogateString, surrMatchSet1) != 0) { 673 log_err("u_strspn couldn't skip \"0xdbff, 0xdfff\" (get first letter).\n"); 674 } 675 if (u_strspn(testSurrogateString, surrMatchSetBad3) != 5) { 676 log_err("u_strspn couldn't skip \"0xdbff, a, b, 0xdbff, 0xdfff\".\n"); 677 } 678 if (u_strspn(testSurrogateString, surrMatchSet4) != 0) { 679 log_err("u_strspn should have returned 0 for empty string.\n"); 680 } 681 } 682 683 /* 684 * All binary Unicode string searches should behave the same for equivalent input. 685 * See Jitterbug 2145. 686 * There are some new functions, too - just test them all. 687 */ 688 static void 689 TestSurrogateSearching() { 690 static const UChar s[]={ 691 /* 0 1 2 3 4 5 6 7 8 9 10 11 */ 692 0x61, 0xd801, 0xdc02, 0x61, 0xdc02, 0x61, 0xd801, 0x61, 0xd801, 0xdc02, 0x61, 0 693 }, sub_a[]={ 694 0x61, 0 695 }, sub_b[]={ 696 0x62, 0 697 }, sub_lead[]={ 698 0xd801, 0 699 }, sub_trail[]={ 700 0xdc02, 0 701 }, sub_supp[]={ 702 0xd801, 0xdc02, 0 703 }, sub_supp2[]={ 704 0xd801, 0xdc03, 0 705 }, sub_a_lead[]={ 706 0x61, 0xd801, 0 707 }, sub_trail_a[]={ 708 0xdc02, 0x61, 0 709 }, sub_aba[]={ 710 0x61, 0x62, 0x61, 0 711 }; 712 static const UChar a=0x61, b=0x62, lead=0xd801, trail=0xdc02, nul=0; 713 static const UChar32 supp=0x10402, supp2=0x10403, ill=0x123456; 714 715 const UChar *first, *last; 716 717 /* search for NUL code point: find end of string */ 718 first=s+u_strlen(s); 719 720 if( 721 first!=u_strchr(s, nul) || 722 first!=u_strchr32(s, nul) || 723 first!=u_memchr(s, nul, UPRV_LENGTHOF(s)) || 724 first!=u_memchr32(s, nul, UPRV_LENGTHOF(s)) || 725 first!=u_strrchr(s, nul) || 726 first!=u_strrchr32(s, nul) || 727 first!=u_memrchr(s, nul, UPRV_LENGTHOF(s)) || 728 first!=u_memrchr32(s, nul, UPRV_LENGTHOF(s)) 729 ) { 730 log_err("error: one of the u_str[|mem][r]chr[32](s, nul) does not find the terminator of s\n"); 731 } 732 733 /* search for empty substring: find beginning of string */ 734 if( 735 s!=u_strstr(s, &nul) || 736 s!=u_strFindFirst(s, -1, &nul, -1) || 737 s!=u_strFindFirst(s, -1, &nul, 0) || 738 s!=u_strFindFirst(s, UPRV_LENGTHOF(s), &nul, -1) || 739 s!=u_strFindFirst(s, UPRV_LENGTHOF(s), &nul, 0) || 740 s!=u_strrstr(s, &nul) || 741 s!=u_strFindLast(s, -1, &nul, -1) || 742 s!=u_strFindLast(s, -1, &nul, 0) || 743 s!=u_strFindLast(s, UPRV_LENGTHOF(s), &nul, -1) || 744 s!=u_strFindLast(s, UPRV_LENGTHOF(s), &nul, 0) 745 ) { 746 log_err("error: one of the u_str[str etc](s, \"\") does not find s itself\n"); 747 } 748 749 /* find 'a' in s[1..10[ */ 750 first=s+3; 751 last=s+7; 752 if( 753 first!=u_strchr(s+1, a) || 754 first!=u_strchr32(s+1, a) || 755 first!=u_memchr(s+1, a, 9) || 756 first!=u_memchr32(s+1, a, 9) || 757 first!=u_strstr(s+1, sub_a) || 758 first!=u_strFindFirst(s+1, -1, sub_a, -1) || 759 first!=u_strFindFirst(s+1, -1, &a, 1) || 760 first!=u_strFindFirst(s+1, 9, sub_a, -1) || 761 first!=u_strFindFirst(s+1, 9, &a, 1) || 762 (s+10)!=u_strrchr(s+1, a) || 763 (s+10)!=u_strrchr32(s+1, a) || 764 last!=u_memrchr(s+1, a, 9) || 765 last!=u_memrchr32(s+1, a, 9) || 766 (s+10)!=u_strrstr(s+1, sub_a) || 767 (s+10)!=u_strFindLast(s+1, -1, sub_a, -1) || 768 (s+10)!=u_strFindLast(s+1, -1, &a, 1) || 769 last!=u_strFindLast(s+1, 9, sub_a, -1) || 770 last!=u_strFindLast(s+1, 9, &a, 1) 771 ) { 772 log_err("error: one of the u_str[chr etc]('a') does not find the correct place\n"); 773 } 774 775 /* do not find 'b' in s[1..10[ */ 776 if( 777 NULL!=u_strchr(s+1, b) || 778 NULL!=u_strchr32(s+1, b) || 779 NULL!=u_memchr(s+1, b, 9) || 780 NULL!=u_memchr32(s+1, b, 9) || 781 NULL!=u_strstr(s+1, sub_b) || 782 NULL!=u_strFindFirst(s+1, -1, sub_b, -1) || 783 NULL!=u_strFindFirst(s+1, -1, &b, 1) || 784 NULL!=u_strFindFirst(s+1, 9, sub_b, -1) || 785 NULL!=u_strFindFirst(s+1, 9, &b, 1) || 786 NULL!=u_strrchr(s+1, b) || 787 NULL!=u_strrchr32(s+1, b) || 788 NULL!=u_memrchr(s+1, b, 9) || 789 NULL!=u_memrchr32(s+1, b, 9) || 790 NULL!=u_strrstr(s+1, sub_b) || 791 NULL!=u_strFindLast(s+1, -1, sub_b, -1) || 792 NULL!=u_strFindLast(s+1, -1, &b, 1) || 793 NULL!=u_strFindLast(s+1, 9, sub_b, -1) || 794 NULL!=u_strFindLast(s+1, 9, &b, 1) 795 ) { 796 log_err("error: one of the u_str[chr etc]('b') incorrectly finds something\n"); 797 } 798 799 /* do not find a non-code point in s[1..10[ */ 800 if( 801 NULL!=u_strchr32(s+1, ill) || 802 NULL!=u_memchr32(s+1, ill, 9) || 803 NULL!=u_strrchr32(s+1, ill) || 804 NULL!=u_memrchr32(s+1, ill, 9) 805 ) { 806 log_err("error: one of the u_str[chr etc](illegal code point) incorrectly finds something\n"); 807 } 808 809 /* find U+d801 in s[1..10[ */ 810 first=s+6; 811 if( 812 first!=u_strchr(s+1, lead) || 813 first!=u_strchr32(s+1, lead) || 814 first!=u_memchr(s+1, lead, 9) || 815 first!=u_memchr32(s+1, lead, 9) || 816 first!=u_strstr(s+1, sub_lead) || 817 first!=u_strFindFirst(s+1, -1, sub_lead, -1) || 818 first!=u_strFindFirst(s+1, -1, &lead, 1) || 819 first!=u_strFindFirst(s+1, 9, sub_lead, -1) || 820 first!=u_strFindFirst(s+1, 9, &lead, 1) || 821 first!=u_strrchr(s+1, lead) || 822 first!=u_strrchr32(s+1, lead) || 823 first!=u_memrchr(s+1, lead, 9) || 824 first!=u_memrchr32(s+1, lead, 9) || 825 first!=u_strrstr(s+1, sub_lead) || 826 first!=u_strFindLast(s+1, -1, sub_lead, -1) || 827 first!=u_strFindLast(s+1, -1, &lead, 1) || 828 first!=u_strFindLast(s+1, 9, sub_lead, -1) || 829 first!=u_strFindLast(s+1, 9, &lead, 1) 830 ) { 831 log_err("error: one of the u_str[chr etc](U+d801) does not find the correct place\n"); 832 } 833 834 /* find U+dc02 in s[1..10[ */ 835 first=s+4; 836 if( 837 first!=u_strchr(s+1, trail) || 838 first!=u_strchr32(s+1, trail) || 839 first!=u_memchr(s+1, trail, 9) || 840 first!=u_memchr32(s+1, trail, 9) || 841 first!=u_strstr(s+1, sub_trail) || 842 first!=u_strFindFirst(s+1, -1, sub_trail, -1) || 843 first!=u_strFindFirst(s+1, -1, &trail, 1) || 844 first!=u_strFindFirst(s+1, 9, sub_trail, -1) || 845 first!=u_strFindFirst(s+1, 9, &trail, 1) || 846 first!=u_strrchr(s+1, trail) || 847 first!=u_strrchr32(s+1, trail) || 848 first!=u_memrchr(s+1, trail, 9) || 849 first!=u_memrchr32(s+1, trail, 9) || 850 first!=u_strrstr(s+1, sub_trail) || 851 first!=u_strFindLast(s+1, -1, sub_trail, -1) || 852 first!=u_strFindLast(s+1, -1, &trail, 1) || 853 first!=u_strFindLast(s+1, 9, sub_trail, -1) || 854 first!=u_strFindLast(s+1, 9, &trail, 1) 855 ) { 856 log_err("error: one of the u_str[chr etc](U+dc02) does not find the correct place\n"); 857 } 858 859 /* find U+10402 in s[1..10[ */ 860 first=s+1; 861 last=s+8; 862 if( 863 first!=u_strchr32(s+1, supp) || 864 first!=u_memchr32(s+1, supp, 9) || 865 first!=u_strstr(s+1, sub_supp) || 866 first!=u_strFindFirst(s+1, -1, sub_supp, -1) || 867 first!=u_strFindFirst(s+1, -1, sub_supp, 2) || 868 first!=u_strFindFirst(s+1, 9, sub_supp, -1) || 869 first!=u_strFindFirst(s+1, 9, sub_supp, 2) || 870 last!=u_strrchr32(s+1, supp) || 871 last!=u_memrchr32(s+1, supp, 9) || 872 last!=u_strrstr(s+1, sub_supp) || 873 last!=u_strFindLast(s+1, -1, sub_supp, -1) || 874 last!=u_strFindLast(s+1, -1, sub_supp, 2) || 875 last!=u_strFindLast(s+1, 9, sub_supp, -1) || 876 last!=u_strFindLast(s+1, 9, sub_supp, 2) 877 ) { 878 log_err("error: one of the u_str[chr etc](U+10402) does not find the correct place\n"); 879 } 880 881 /* do not find U+10402 in a single UChar */ 882 if( 883 NULL!=u_memchr32(s+1, supp, 1) || 884 NULL!=u_strFindFirst(s+1, 1, sub_supp, -1) || 885 NULL!=u_strFindFirst(s+1, 1, sub_supp, 2) || 886 NULL!=u_memrchr32(s+1, supp, 1) || 887 NULL!=u_strFindLast(s+1, 1, sub_supp, -1) || 888 NULL!=u_strFindLast(s+1, 1, sub_supp, 2) || 889 NULL!=u_memrchr32(s+2, supp, 1) || 890 NULL!=u_strFindLast(s+2, 1, sub_supp, -1) || 891 NULL!=u_strFindLast(s+2, 1, sub_supp, 2) 892 ) { 893 log_err("error: one of the u_str[chr etc](U+10402) incorrectly finds a supplementary c.p. in a single UChar\n"); 894 } 895 896 /* do not find U+10403 in s[1..10[ */ 897 if( 898 NULL!=u_strchr32(s+1, supp2) || 899 NULL!=u_memchr32(s+1, supp2, 9) || 900 NULL!=u_strstr(s+1, sub_supp2) || 901 NULL!=u_strFindFirst(s+1, -1, sub_supp2, -1) || 902 NULL!=u_strFindFirst(s+1, -1, sub_supp2, 2) || 903 NULL!=u_strFindFirst(s+1, 9, sub_supp2, -1) || 904 NULL!=u_strFindFirst(s+1, 9, sub_supp2, 2) || 905 NULL!=u_strrchr32(s+1, supp2) || 906 NULL!=u_memrchr32(s+1, supp2, 9) || 907 NULL!=u_strrstr(s+1, sub_supp2) || 908 NULL!=u_strFindLast(s+1, -1, sub_supp2, -1) || 909 NULL!=u_strFindLast(s+1, -1, sub_supp2, 2) || 910 NULL!=u_strFindLast(s+1, 9, sub_supp2, -1) || 911 NULL!=u_strFindLast(s+1, 9, sub_supp2, 2) 912 ) { 913 log_err("error: one of the u_str[chr etc](U+10403) incorrectly finds something\n"); 914 } 915 916 /* find <0061 d801> in s[1..10[ */ 917 first=s+5; 918 if( 919 first!=u_strstr(s+1, sub_a_lead) || 920 first!=u_strFindFirst(s+1, -1, sub_a_lead, -1) || 921 first!=u_strFindFirst(s+1, -1, sub_a_lead, 2) || 922 first!=u_strFindFirst(s+1, 9, sub_a_lead, -1) || 923 first!=u_strFindFirst(s+1, 9, sub_a_lead, 2) || 924 first!=u_strrstr(s+1, sub_a_lead) || 925 first!=u_strFindLast(s+1, -1, sub_a_lead, -1) || 926 first!=u_strFindLast(s+1, -1, sub_a_lead, 2) || 927 first!=u_strFindLast(s+1, 9, sub_a_lead, -1) || 928 first!=u_strFindLast(s+1, 9, sub_a_lead, 2) 929 ) { 930 log_err("error: one of the u_str[str etc](<0061 d801>) does not find the correct place\n"); 931 } 932 933 /* find <dc02 0061> in s[1..10[ */ 934 first=s+4; 935 if( 936 first!=u_strstr(s+1, sub_trail_a) || 937 first!=u_strFindFirst(s+1, -1, sub_trail_a, -1) || 938 first!=u_strFindFirst(s+1, -1, sub_trail_a, 2) || 939 first!=u_strFindFirst(s+1, 9, sub_trail_a, -1) || 940 first!=u_strFindFirst(s+1, 9, sub_trail_a, 2) || 941 first!=u_strrstr(s+1, sub_trail_a) || 942 first!=u_strFindLast(s+1, -1, sub_trail_a, -1) || 943 first!=u_strFindLast(s+1, -1, sub_trail_a, 2) || 944 first!=u_strFindLast(s+1, 9, sub_trail_a, -1) || 945 first!=u_strFindLast(s+1, 9, sub_trail_a, 2) 946 ) { 947 log_err("error: one of the u_str[str etc](<dc02 0061>) does not find the correct place\n"); 948 } 949 950 /* do not find "aba" in s[1..10[ */ 951 if( 952 NULL!=u_strstr(s+1, sub_aba) || 953 NULL!=u_strFindFirst(s+1, -1, sub_aba, -1) || 954 NULL!=u_strFindFirst(s+1, -1, sub_aba, 3) || 955 NULL!=u_strFindFirst(s+1, 9, sub_aba, -1) || 956 NULL!=u_strFindFirst(s+1, 9, sub_aba, 3) || 957 NULL!=u_strrstr(s+1, sub_aba) || 958 NULL!=u_strFindLast(s+1, -1, sub_aba, -1) || 959 NULL!=u_strFindLast(s+1, -1, sub_aba, 3) || 960 NULL!=u_strFindLast(s+1, 9, sub_aba, -1) || 961 NULL!=u_strFindLast(s+1, 9, sub_aba, 3) 962 ) { 963 log_err("error: one of the u_str[str etc](\"aba\") incorrectly finds something\n"); 964 } 965 } 966 967 static void TestStringCopy() 968 { 969 UChar temp[40]; 970 UChar *result=0; 971 UChar subString[5]; 972 UChar uchars[]={0x61, 0x62, 0x63, 0x00}; 973 char charOut[40]; 974 char chars[]="abc"; /* needs default codepage */ 975 976 log_verbose("Testing u_uastrncpy() and u_uastrcpy()"); 977 978 u_uastrcpy(temp, "abc"); 979 if(u_strcmp(temp, uchars) != 0) { 980 log_err("There is an error in u_uastrcpy() Expected %s Got %s\n", austrdup(uchars), austrdup(temp)); 981 } 982 983 temp[0] = 0xFB; /* load garbage into it */ 984 temp[1] = 0xFB; 985 temp[2] = 0xFB; 986 temp[3] = 0xFB; 987 988 u_uastrncpy(temp, "abcabcabc", 3); 989 if(u_strncmp(uchars, temp, 3) != 0){ 990 log_err("There is an error in u_uastrncpy() Expected %s Got %s\n", austrdup(uchars), austrdup(temp)); 991 } 992 if(temp[3] != 0xFB) { 993 log_err("u_uastrncpy wrote past it's bounds. Expected undisturbed byte at 3\n"); 994 } 995 996 charOut[0] = (char)0x7B; /* load garbage into it */ 997 charOut[1] = (char)0x7B; 998 charOut[2] = (char)0x7B; 999 charOut[3] = (char)0x7B; 1000 1001 temp[0] = 0x0061; 1002 temp[1] = 0x0062; 1003 temp[2] = 0x0063; 1004 temp[3] = 0x0061; 1005 temp[4] = 0x0062; 1006 temp[5] = 0x0063; 1007 temp[6] = 0x0000; 1008 1009 u_austrncpy(charOut, temp, 3); 1010 if(strncmp(chars, charOut, 3) != 0){ 1011 log_err("There is an error in u_austrncpy() Expected %s Got %s\n", austrdup(uchars), austrdup(temp)); 1012 } 1013 if(charOut[3] != (char)0x7B) { 1014 log_err("u_austrncpy wrote past it's bounds. Expected undisturbed byte at 3\n"); 1015 } 1016 1017 /*Testing u_strchr()*/ 1018 log_verbose("Testing u_strchr\n"); 1019 temp[0]=0x42; 1020 temp[1]=0x62; 1021 temp[2]=0x62; 1022 temp[3]=0x63; 1023 temp[4]=0xd841; 1024 temp[5]=0xd841; 1025 temp[6]=0xdc02; 1026 temp[7]=0; 1027 result=u_strchr(temp, (UChar)0x62); 1028 if(result != temp+1){ 1029 log_err("There is an error in u_strchr() Expected match at position 1 Got %ld (pointer 0x%lx)\n", result-temp, result); 1030 } 1031 /*Testing u_strstr()*/ 1032 log_verbose("Testing u_strstr\n"); 1033 subString[0]=0x62; 1034 subString[1]=0x63; 1035 subString[2]=0; 1036 result=u_strstr(temp, subString); 1037 if(result != temp+2){ 1038 log_err("There is an error in u_strstr() Expected match at position 2 Got %ld (pointer 0x%lx)\n", result-temp, result); 1039 } 1040 result=u_strstr(temp, subString+2); /* subString+2 is an empty string */ 1041 if(result != temp){ 1042 log_err("There is an error in u_strstr() Expected match at position 0 Got %ld (pointer 0x%lx)\n", result-temp, result); 1043 } 1044 result=u_strstr(subString, temp); 1045 if(result != NULL){ 1046 log_err("There is an error in u_strstr() Expected NULL \"not found\" Got non-NULL \"found\" result\n"); 1047 } 1048 1049 /*Testing u_strchr32*/ 1050 log_verbose("Testing u_strchr32\n"); 1051 result=u_strchr32(temp, (UChar32)0x62); 1052 if(result != temp+1){ 1053 log_err("There is an error in u_strchr32() Expected match at position 1 Got %ld (pointer 0x%lx)\n", result-temp, result); 1054 } 1055 result=u_strchr32(temp, (UChar32)0xfb); 1056 if(result != NULL){ 1057 log_err("There is an error in u_strchr32() Expected NULL \"not found\" Got non-NULL \"found\" result\n"); 1058 } 1059 result=u_strchr32(temp, (UChar32)0x20402); 1060 if(result != temp+5){ 1061 log_err("There is an error in u_strchr32() Expected match at position 5 Got %ld (pointer 0x%lx)\n", result-temp, result); 1062 } 1063 1064 temp[7]=0xfc00; 1065 result=u_memchr32(temp, (UChar32)0x20402, 7); 1066 if(result != temp+5){ 1067 log_err("There is an error in u_memchr32() Expected match at position 5 Got %ld (pointer 0x%lx)\n", result-temp, result); 1068 } 1069 result=u_memchr32(temp, (UChar32)0x20402, 6); 1070 if(result != NULL){ 1071 log_err("There is an error in u_memchr32() Expected no match Got %ld (pointer 0x%lx)\n", result-temp, result); 1072 } 1073 result=u_memchr32(temp, (UChar32)0x20402, 1); 1074 if(result != NULL){ 1075 log_err("There is an error in u_memchr32() Expected no match Got %ld (pointer 0x%lx)\n", result-temp, result); 1076 } 1077 result=u_memchr32(temp, (UChar32)0xfc00, 8); 1078 if(result != temp+7){ 1079 log_err("There is an error in u_memchr32() Expected match at position 7 Got %ld (pointer 0x%lx)\n", result-temp, result); 1080 } 1081 } 1082 1083 /* test u_unescape() and u_unescapeAt() ------------------------------------- */ 1084 1085 static void 1086 TestUnescape() { 1087 static UChar buffer[200]; 1088 1089 static const char* input = 1090 "Sch\\u00f6nes Auto: \\u20ac 11240.\\fPrivates Zeichen: \\U00102345\\e\\cC\\n \\x1b\\x{263a}"; 1091 1092 static const UChar expect[]={ 1093 0x53, 0x63, 0x68, 0xf6, 0x6e, 0x65, 0x73, 0x20, 0x41, 0x75, 0x74, 0x6f, 0x3a, 0x20, 1094 0x20ac, 0x20, 0x31, 0x31, 0x32, 0x34, 0x30, 0x2e, 0x0c, 1095 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x73, 0x20, 1096 0x5a, 0x65, 0x69, 0x63, 0x68, 0x65, 0x6e, 0x3a, 0x20, 0xdbc8, 0xdf45, 0x1b, 0x03, 0x0a, 0x20, 0x1b, 0x263A, 0 1097 }; 1098 static const int32_t explength = UPRV_LENGTHOF(expect)-1; 1099 int32_t length; 1100 1101 /* test u_unescape() */ 1102 length=u_unescape(input, buffer, UPRV_LENGTHOF(buffer)); 1103 if(length!=explength || u_strcmp(buffer, expect)!=0) { 1104 log_err("failure in u_unescape(): length %d!=%d and/or incorrect result string\n", length, 1105 explength); 1106 } 1107 1108 /* try preflighting */ 1109 length=u_unescape(input, NULL, UPRV_LENGTHOF(buffer)); 1110 if(length!=explength || u_strcmp(buffer, expect)!=0) { 1111 log_err("failure in u_unescape(preflighting): length %d!=%d\n", length, explength); 1112 } 1113 1114 /* ### TODO: test u_unescapeAt() */ 1115 } 1116 1117 /* test code point counting functions --------------------------------------- */ 1118 1119 /* reference implementation of u_strHasMoreChar32Than() */ 1120 static int32_t 1121 _refStrHasMoreChar32Than(const UChar *s, int32_t length, int32_t number) { 1122 int32_t count=u_countChar32(s, length); 1123 return count>number; 1124 } 1125 1126 /* compare the real function against the reference */ 1127 static void 1128 _testStrHasMoreChar32Than(const UChar *s, int32_t i, int32_t length, int32_t number) { 1129 if(u_strHasMoreChar32Than(s, length, number)!=_refStrHasMoreChar32Than(s, length, number)) { 1130 log_err("u_strHasMoreChar32Than(s+%d, %d, %d)=%hd is wrong\n", 1131 i, length, number, u_strHasMoreChar32Than(s, length, number)); 1132 } 1133 } 1134 1135 static void 1136 TestCountChar32() { 1137 static const UChar string[]={ 1138 0x61, 0x62, 0xd800, 0xdc00, 1139 0xd801, 0xdc01, 0x63, 0xd802, 1140 0x64, 0xdc03, 0x65, 0x66, 1141 0xd804, 0xdc04, 0xd805, 0xdc05, 1142 0x67 1143 }; 1144 UChar buffer[100]; 1145 int32_t i, length, number; 1146 1147 /* test u_strHasMoreChar32Than() with length>=0 */ 1148 length=UPRV_LENGTHOF(string); 1149 while(length>=0) { 1150 for(i=0; i<=length; ++i) { 1151 for(number=-1; number<=((length-i)+2); ++number) { 1152 _testStrHasMoreChar32Than(string+i, i, length-i, number); 1153 } 1154 } 1155 --length; 1156 } 1157 1158 /* test u_strHasMoreChar32Than() with NUL-termination (length=-1) */ 1159 length=UPRV_LENGTHOF(string); 1160 u_memcpy(buffer, string, length); 1161 while(length>=0) { 1162 buffer[length]=0; 1163 for(i=0; i<=length; ++i) { 1164 for(number=-1; number<=((length-i)+2); ++number) { 1165 _testStrHasMoreChar32Than(buffer+i, i, -1, number); 1166 } 1167 } 1168 --length; 1169 } 1170 1171 /* test u_strHasMoreChar32Than() with NULL string (bad input) */ 1172 for(length=-1; length<=1; ++length) { 1173 for(i=0; i<=length; ++i) { 1174 for(number=-2; number<=2; ++number) { 1175 _testStrHasMoreChar32Than(NULL, 0, length, number); 1176 } 1177 } 1178 } 1179 } 1180 1181 /* UCharIterator ------------------------------------------------------------ */ 1182 1183 /* 1184 * Compare results from two iterators, should be same. 1185 * Assume that the text is not empty and that 1186 * iteration start==0 and iteration limit==length. 1187 */ 1188 static void 1189 compareIterators(UCharIterator *iter1, const char *n1, 1190 UCharIterator *iter2, const char *n2) { 1191 int32_t i, pos1, pos2, middle, length; 1192 UChar32 c1, c2; 1193 1194 /* compare lengths */ 1195 length=iter1->getIndex(iter1, UITER_LENGTH); 1196 pos2=iter2->getIndex(iter2, UITER_LENGTH); 1197 if(length!=pos2) { 1198 log_err("%s->getIndex(length)=%d != %d=%s->getIndex(length)\n", n1, length, pos2, n2); 1199 return; 1200 } 1201 1202 /* set into the middle */ 1203 middle=length/2; 1204 1205 pos1=iter1->move(iter1, middle, UITER_ZERO); 1206 if(pos1!=middle) { 1207 log_err("%s->move(from 0 to middle %d)=%d does not move to the middle\n", n1, middle, pos1); 1208 return; 1209 } 1210 1211 pos2=iter2->move(iter2, middle, UITER_ZERO); 1212 if(pos2!=middle) { 1213 log_err("%s->move(from 0 to middle %d)=%d does not move to the middle\n", n2, middle, pos2); 1214 return; 1215 } 1216 1217 /* test current() */ 1218 c1=iter1->current(iter1); 1219 c2=iter2->current(iter2); 1220 if(c1!=c2) { 1221 log_err("%s->current()=U+%04x != U+%04x=%s->current() at middle=%d\n", n1, c1, c2, n2, middle); 1222 return; 1223 } 1224 1225 /* move forward 3 UChars */ 1226 for(i=0; i<3; ++i) { 1227 c1=iter1->next(iter1); 1228 c2=iter2->next(iter2); 1229 if(c1!=c2) { 1230 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)); 1231 return; 1232 } 1233 } 1234 1235 /* move backward 5 UChars */ 1236 for(i=0; i<5; ++i) { 1237 c1=iter1->previous(iter1); 1238 c2=iter2->previous(iter2); 1239 if(c1!=c2) { 1240 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)); 1241 return; 1242 } 1243 } 1244 1245 /* iterate forward from the beginning */ 1246 pos1=iter1->move(iter1, 0, UITER_START); 1247 if(pos1<0) { 1248 log_err("%s->move(start) failed\n", n1); 1249 return; 1250 } 1251 if(!iter1->hasNext(iter1)) { 1252 log_err("%s->hasNext() at the start returns FALSE\n", n1); 1253 return; 1254 } 1255 1256 pos2=iter2->move(iter2, 0, UITER_START); 1257 if(pos2<0) { 1258 log_err("%s->move(start) failed\n", n2); 1259 return; 1260 } 1261 if(!iter2->hasNext(iter2)) { 1262 log_err("%s->hasNext() at the start returns FALSE\n", n2); 1263 return; 1264 } 1265 1266 do { 1267 c1=iter1->next(iter1); 1268 c2=iter2->next(iter2); 1269 if(c1!=c2) { 1270 log_err("%s->next()=U+%04x != U+%04x=%s->next() at %d\n", n1, c1, c2, n2, iter1->getIndex(iter1, UITER_CURRENT)); 1271 return; 1272 } 1273 } while(c1>=0); 1274 1275 if(iter1->hasNext(iter1)) { 1276 log_err("%s->hasNext() at the end returns TRUE\n", n1); 1277 return; 1278 } 1279 if(iter2->hasNext(iter2)) { 1280 log_err("%s->hasNext() at the end returns TRUE\n", n2); 1281 return; 1282 } 1283 1284 /* back to the middle */ 1285 pos1=iter1->move(iter1, middle, UITER_ZERO); 1286 if(pos1!=middle) { 1287 log_err("%s->move(from end to middle %d)=%d does not move to the middle\n", n1, middle, pos1); 1288 return; 1289 } 1290 1291 pos2=iter2->move(iter2, middle, UITER_ZERO); 1292 if(pos2!=middle) { 1293 log_err("%s->move(from end to middle %d)=%d does not move to the middle\n", n2, middle, pos2); 1294 return; 1295 } 1296 1297 /* move to index 1 */ 1298 pos1=iter1->move(iter1, 1, UITER_ZERO); 1299 if(pos1!=1) { 1300 log_err("%s->move(from middle %d to 1)=%d does not move to 1\n", n1, middle, pos1); 1301 return; 1302 } 1303 1304 pos2=iter2->move(iter2, 1, UITER_ZERO); 1305 if(pos2!=1) { 1306 log_err("%s->move(from middle %d to 1)=%d does not move to 1\n", n2, middle, pos2); 1307 return; 1308 } 1309 1310 /* iterate backward from the end */ 1311 pos1=iter1->move(iter1, 0, UITER_LIMIT); 1312 if(pos1<0) { 1313 log_err("%s->move(limit) failed\n", n1); 1314 return; 1315 } 1316 if(!iter1->hasPrevious(iter1)) { 1317 log_err("%s->hasPrevious() at the end returns FALSE\n", n1); 1318 return; 1319 } 1320 1321 pos2=iter2->move(iter2, 0, UITER_LIMIT); 1322 if(pos2<0) { 1323 log_err("%s->move(limit) failed\n", n2); 1324 return; 1325 } 1326 if(!iter2->hasPrevious(iter2)) { 1327 log_err("%s->hasPrevious() at the end returns FALSE\n", n2); 1328 return; 1329 } 1330 1331 do { 1332 c1=iter1->previous(iter1); 1333 c2=iter2->previous(iter2); 1334 if(c1!=c2) { 1335 log_err("%s->previous()=U+%04x != U+%04x=%s->previous() at %d\n", n1, c1, c2, n2, iter1->getIndex(iter1, UITER_CURRENT)); 1336 return; 1337 } 1338 } while(c1>=0); 1339 1340 if(iter1->hasPrevious(iter1)) { 1341 log_err("%s->hasPrevious() at the start returns TRUE\n", n1); 1342 return; 1343 } 1344 if(iter2->hasPrevious(iter2)) { 1345 log_err("%s->hasPrevious() at the start returns TRUE\n", n2); 1346 return; 1347 } 1348 } 1349 1350 /* 1351 * Test the iterator's getState() and setState() functions. 1352 * iter1 and iter2 must be set up for the same iterator type and the same string 1353 * but may be physically different structs (different addresses). 1354 * 1355 * Assume that the text is not empty and that 1356 * iteration start==0 and iteration limit==length. 1357 * It must be 2<=middle<=length-2. 1358 */ 1359 static void 1360 testIteratorState(UCharIterator *iter1, UCharIterator *iter2, const char *n, int32_t middle) { 1361 UChar32 u[4]; 1362 1363 UErrorCode errorCode; 1364 UChar32 c; 1365 uint32_t state; 1366 int32_t i, j; 1367 1368 /* get four UChars from the middle of the string */ 1369 iter1->move(iter1, middle-2, UITER_ZERO); 1370 for(i=0; i<4; ++i) { 1371 c=iter1->next(iter1); 1372 if(c<0) { 1373 /* the test violates the assumptions, see comment above */ 1374 log_err("test error: %s[%d]=%d\n", n, middle-2+i, c); 1375 return; 1376 } 1377 u[i]=c; 1378 } 1379 1380 /* move to the middle and get the state */ 1381 iter1->move(iter1, -2, UITER_CURRENT); 1382 state=uiter_getState(iter1); 1383 1384 /* set the state into the second iterator and compare the results */ 1385 errorCode=U_ZERO_ERROR; 1386 uiter_setState(iter2, state, &errorCode); 1387 if(U_FAILURE(errorCode)) { 1388 log_err("%s->setState(0x%x) failed: %s\n", n, state, u_errorName(errorCode)); 1389 return; 1390 } 1391 1392 c=iter2->current(iter2); 1393 if(c!=u[2]) { 1394 log_err("%s->current(at %d)=U+%04x!=U+%04x\n", n, middle, c, u[2]); 1395 } 1396 1397 c=iter2->previous(iter2); 1398 if(c!=u[1]) { 1399 log_err("%s->previous(at %d)=U+%04x!=U+%04x\n", n, middle-1, c, u[1]); 1400 } 1401 1402 iter2->move(iter2, 2, UITER_CURRENT); 1403 c=iter2->next(iter2); 1404 if(c!=u[3]) { 1405 log_err("%s->next(at %d)=U+%04x!=U+%04x\n", n, middle+1, c, u[3]); 1406 } 1407 1408 iter2->move(iter2, -3, UITER_CURRENT); 1409 c=iter2->previous(iter2); 1410 if(c!=u[0]) { 1411 log_err("%s->previous(at %d)=U+%04x!=U+%04x\n", n, middle-2, c, u[0]); 1412 } 1413 1414 /* move the second iterator back to the middle */ 1415 iter2->move(iter2, 1, UITER_CURRENT); 1416 iter2->next(iter2); 1417 1418 /* check that both are in the middle */ 1419 i=iter1->getIndex(iter1, UITER_CURRENT); 1420 j=iter2->getIndex(iter2, UITER_CURRENT); 1421 if(i!=middle) { 1422 log_err("%s->getIndex(current)=%d!=%d as expected\n", n, i, middle); 1423 } 1424 if(i!=j) { 1425 log_err("%s->getIndex(current)=%d!=%d after setState()\n", n, j, i); 1426 } 1427 1428 /* compare lengths */ 1429 i=iter1->getIndex(iter1, UITER_LENGTH); 1430 j=iter2->getIndex(iter2, UITER_LENGTH); 1431 if(i!=j) { 1432 log_err("%s->getIndex(length)=%d!=%d before/after setState()\n", n, i, j); 1433 } 1434 } 1435 1436 static void 1437 TestUCharIterator() { 1438 static const UChar text[]={ 1439 0x61, 0x62, 0x63, 0xd801, 0xdffd, 0x78, 0x79, 0x7a, 0 1440 }; 1441 char bytes[40]; 1442 1443 UCharIterator iter, iter1, iter2; 1444 UConverter *cnv; 1445 UErrorCode errorCode; 1446 int32_t length; 1447 1448 /* simple API/code coverage - test NOOP UCharIterator */ 1449 uiter_setString(&iter, NULL, 0); 1450 if( iter.current(&iter)!=-1 || iter.next(&iter)!=-1 || iter.previous(&iter)!=-1 || 1451 iter.move(&iter, 1, UITER_CURRENT) || iter.getIndex(&iter, UITER_CURRENT)!=0 || 1452 iter.hasNext(&iter) || iter.hasPrevious(&iter) 1453 ) { 1454 log_err("NOOP UCharIterator behaves unexpectedly\n"); 1455 } 1456 1457 /* test get/set state */ 1458 length=UPRV_LENGTHOF(text)-1; 1459 uiter_setString(&iter1, text, -1); 1460 uiter_setString(&iter2, text, length); 1461 testIteratorState(&iter1, &iter2, "UTF16IteratorState", length/2); 1462 testIteratorState(&iter1, &iter2, "UTF16IteratorStatePlus1", length/2+1); 1463 1464 /* compare the same string between UTF-16 and UTF-8 UCharIterators ------ */ 1465 errorCode=U_ZERO_ERROR; 1466 u_strToUTF8(bytes, sizeof(bytes), &length, text, -1, &errorCode); 1467 if(U_FAILURE(errorCode)) { 1468 log_err("u_strToUTF8() failed, %s\n", u_errorName(errorCode)); 1469 return; 1470 } 1471 1472 uiter_setString(&iter1, text, -1); 1473 uiter_setUTF8(&iter2, bytes, length); 1474 compareIterators(&iter1, "UTF16Iterator", &iter2, "UTF8Iterator"); 1475 1476 /* try again with length=-1 */ 1477 uiter_setUTF8(&iter2, bytes, -1); 1478 compareIterators(&iter1, "UTF16Iterator", &iter2, "UTF8Iterator_1"); 1479 1480 /* test get/set state */ 1481 length=UPRV_LENGTHOF(text)-1; 1482 uiter_setUTF8(&iter1, bytes, -1); 1483 testIteratorState(&iter1, &iter2, "UTF8IteratorState", length/2); 1484 testIteratorState(&iter1, &iter2, "UTF8IteratorStatePlus1", length/2+1); 1485 1486 /* compare the same string between UTF-16 and UTF-16BE UCharIterators --- */ 1487 errorCode=U_ZERO_ERROR; 1488 cnv=ucnv_open("UTF-16BE", &errorCode); 1489 length=ucnv_fromUChars(cnv, bytes, sizeof(bytes), text, -1, &errorCode); 1490 ucnv_close(cnv); 1491 if(U_FAILURE(errorCode)) { 1492 log_err("ucnv_fromUChars(UTF-16BE) failed, %s\n", u_errorName(errorCode)); 1493 return; 1494 } 1495 1496 /* terminate with a _pair_ of 0 bytes - a UChar NUL in UTF-16BE (length is known to be ok) */ 1497 bytes[length]=bytes[length+1]=0; 1498 1499 uiter_setString(&iter1, text, -1); 1500 uiter_setUTF16BE(&iter2, bytes, length); 1501 compareIterators(&iter1, "UTF16Iterator", &iter2, "UTF16BEIterator"); 1502 1503 /* try again with length=-1 */ 1504 uiter_setUTF16BE(&iter2, bytes, -1); 1505 compareIterators(&iter1, "UTF16Iterator", &iter2, "UTF16BEIterator_1"); 1506 1507 /* try again after moving the bytes up one, and with length=-1 */ 1508 memmove(bytes+1, bytes, length+2); 1509 uiter_setUTF16BE(&iter2, bytes+1, -1); 1510 compareIterators(&iter1, "UTF16Iterator", &iter2, "UTF16BEIteratorMoved1"); 1511 1512 /* ### TODO test other iterators: CharacterIterator, Replaceable */ 1513 } 1514
