Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: source/test/cintltst/custrtst.c

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

Powered by Google App Engine
This is Rietveld 408576698