1 /*
2 * This stuff is all stolen (with permission, since it was in the public
3 * domain) from Henry Spencer's string and memory library. Thanks Henry.
4 */
5
6 /*
7 * Test program for string(3) routines.
8 *
9 * Note that at least one Bell Labs implementation of the string
10 * routines flunks a couple of these tests -- the ones which test
11 * behavior on "negative" characters.
12 */
13
14 #include <stdio.h>
15 #include <string.h>
16
17 char * index();
18 char * rindex();
19
20 #define STREQ(a, b) (strcmp((a), (b)) == 0)
21
22 char *it = "<UNSET>"; /* Routine name for message routines. */
23 int waserror = 0; /* For exit status. */
24
25 char uctest[] = "\004\203"; /* For testing signedness of chars. */
26 int charsigned; /* Result. */
27
28 /*
29 - check - complain if condition is not true
30 */
31 void
check(thing,number)32 check(thing, number)
33 int thing;
34 int number; /* Test number for error message. */
35 {
36 if (!thing) {
37 printf("%s flunked test %d\n", it, number);
38 waserror = 1;
39 }
40 }
41
42 /*
43 - equal - complain if first two args don't strcmp as equal
44 */
45 void
equal(a,b,number)46 equal(a, b, number)
47 char *a;
48 char *b;
49 int number; /* Test number for error message. */
50 {
51 check(a != NULL && b != NULL && STREQ(a, b), number);
52 }
53
54 char one[50];
55 char two[50];
56
57 #ifdef UNIXERR
58 #define ERR 1
59 #endif
60 #ifdef BERKERR
61 #define ERR 1
62 #endif
63 #ifdef ERR
64 int f;
65 extern char *sys_errlist[];
66 extern int sys_nerr;
67 extern int errno;
68 #endif
69
70 /* ARGSUSED */
main(argc,argv)71 main(argc, argv)
72 int argc;
73 char *argv[];
74 {
75 /*
76 * First, establish whether chars are signed.
77 */
78 if (uctest[0] < uctest[1])
79 charsigned = 0;
80 else
81 charsigned = 1;
82
83 /*
84 * Then, do the rest of the work. Split into two functions because
85 * some compilers get unhappy about a single immense function.
86 */
87 first();
88 second();
89
90 exit((waserror) ? 1 : 0);
91 }
92
first()93 first()
94 {
95 /*
96 * Test strcmp first because we use it to test other things.
97 */
98 it = "strcmp";
99 check(strcmp("", "") == 0, 1); /* Trivial case. */
100 check(strcmp("a", "a") == 0, 2); /* Identity. */
101 check(strcmp("abc", "abc") == 0, 3); /* Multicharacter. */
102 check(strcmp("abc", "abcd") < 0, 4); /* Length mismatches. */
103 check(strcmp("abcd", "abc") > 0, 5);
104 check(strcmp("abcd", "abce") < 0, 6); /* Honest miscompares. */
105 check(strcmp("abce", "abcd") > 0, 7);
106 check(strcmp("a\203", "a") > 0, 8); /* Tricky if char signed. */
107 if (charsigned) /* Sign-bit comparison. */
108 check(strcmp("a\203", "a\003") < 0, 9);
109 else
110 check(strcmp("a\203", "a\003") > 0, 9);
111 check(strcmp("a", "a\203") < 0, 10); /* Tricky if char signed. */
112
113 /*
114 * Test strcpy next because we need it to set up other tests.
115 */
116 it = "strcpy";
117 check(strcpy(one, "abcd") == one, 1); /* Returned value. */
118 equal(one, "abcd", 2); /* Basic test. */
119
120 (void) strcpy(one, "x");
121 equal(one, "x", 3); /* Writeover. */
122 equal(one+2, "cd", 4); /* Wrote too much? */
123
124 (void) strcpy(two, "hi there");
125 (void) strcpy(one, two);
126 equal(one, "hi there", 5); /* Basic test encore. */
127 equal(two, "hi there", 6); /* Stomped on source? */
128
129 (void) strcpy(one, "");
130 equal(one, "", 7); /* Boundary condition. */
131
132 /*
133 * strcat
134 */
135 it = "strcat";
136 (void) strcpy(one, "ijk");
137 check(strcat(one, "lmn") == one, 1); /* Returned value. */
138 equal(one, "ijklmn", 2); /* Basic test. */
139
140 (void) strcpy(one, "x");
141 (void) strcat(one, "yz");
142 equal(one, "xyz", 3); /* Writeover. */
143 equal(one+4, "mn", 4); /* Wrote too much? */
144
145 (void) strcpy(one, "gh");
146 (void) strcpy(two, "ef");
147 (void) strcat(one, two);
148 equal(one, "ghef", 5); /* Basic test encore. */
149 equal(two, "ef", 6); /* Stomped on source? */
150
151 (void) strcpy(one, "");
152 (void) strcat(one, "");
153 equal(one, "", 7); /* Boundary conditions. */
154 (void) strcpy(one, "ab");
155 (void) strcat(one, "");
156 equal(one, "ab", 8);
157 (void) strcpy(one, "");
158 (void) strcat(one, "cd");
159 equal(one, "cd", 9);
160
161 /*
162 * strncat - first test it as strcat, with big counts, then
163 * test the count mechanism.
164 */
165 it = "strncat";
166 (void) strcpy(one, "ijk");
167 check(strncat(one, "lmn", 99) == one, 1); /* Returned value. */
168 equal(one, "ijklmn", 2); /* Basic test. */
169
170 (void) strcpy(one, "x");
171 (void) strncat(one, "yz", 99);
172 equal(one, "xyz", 3); /* Writeover. */
173 equal(one+4, "mn", 4); /* Wrote too much? */
174
175 (void) strcpy(one, "gh");
176 (void) strcpy(two, "ef");
177 (void) strncat(one, two, 99);
178 equal(one, "ghef", 5); /* Basic test encore. */
179 equal(two, "ef", 6); /* Stomped on source? */
180
181 (void) strcpy(one, "");
182 (void) strncat(one, "", 99);
183 equal(one, "", 7); /* Boundary conditions. */
184 (void) strcpy(one, "ab");
185 (void) strncat(one, "", 99);
186 equal(one, "ab", 8);
187 (void) strcpy(one, "");
188 (void) strncat(one, "cd", 99);
189 equal(one, "cd", 9);
190
191 (void) strcpy(one, "ab");
192 (void) strncat(one, "cdef", 2);
193 equal(one, "abcd", 10); /* Count-limited. */
194
195 (void) strncat(one, "gh", 0);
196 equal(one, "abcd", 11); /* Zero count. */
197
198 (void) strncat(one, "gh", 2);
199 equal(one, "abcdgh", 12); /* Count and length equal. */
200
201 /*
202 * strncmp - first test as strcmp with big counts, then test
203 * count code.
204 */
205 it = "strncmp";
206 check(strncmp("", "", 99) == 0, 1); /* Trivial case. */
207 check(strncmp("a", "a", 99) == 0, 2); /* Identity. */
208 check(strncmp("abc", "abc", 99) == 0, 3); /* Multicharacter. */
209 check(strncmp("abc", "abcd", 99) < 0, 4); /* Length unequal. */
210 check(strncmp("abcd", "abc", 99) > 0, 5);
211 check(strncmp("abcd", "abce", 99) < 0, 6); /* Honestly unequal. */
212 check(strncmp("abce", "abcd", 99) > 0, 7);
213 check(strncmp("a\203", "a", 2) > 0, 8); /* Tricky if '\203' < 0 */
214 if (charsigned) /* Sign-bit comparison. */
215 check(strncmp("a\203", "a\003", 2) < 0, 9);
216 else
217 check(strncmp("a\203", "a\003", 2) > 0, 9);
218 check(strncmp("abce", "abcd", 3) == 0, 10); /* Count limited. */
219 check(strncmp("abce", "abc", 3) == 0, 11); /* Count == length. */
220 check(strncmp("abcd", "abce", 4) < 0, 12); /* Nudging limit. */
221 check(strncmp("abc", "def", 0) == 0, 13); /* Zero count. */
222
223 /*
224 * strncpy - testing is a bit different because of odd semantics
225 */
226 it = "strncpy";
227 check(strncpy(one, "abc", 4) == one, 1); /* Returned value. */
228 equal(one, "abc", 2); /* Did the copy go right? */
229
230 (void) strcpy(one, "abcdefgh");
231 (void) strncpy(one, "xyz", 2);
232 equal(one, "xycdefgh", 3); /* Copy cut by count. */
233
234 (void) strcpy(one, "abcdefgh");
235 (void) strncpy(one, "xyz", 3); /* Copy cut just before NUL. */
236 equal(one, "xyzdefgh", 4);
237
238 (void) strcpy(one, "abcdefgh");
239 (void) strncpy(one, "xyz", 4); /* Copy just includes NUL. */
240 equal(one, "xyz", 5);
241 equal(one+4, "efgh", 6); /* Wrote too much? */
242
243 (void) strcpy(one, "abcdefgh");
244 (void) strncpy(one, "xyz", 5); /* Copy includes padding. */
245 equal(one, "xyz", 7);
246 equal(one+4, "", 8);
247 equal(one+5, "fgh", 9);
248
249 (void) strcpy(one, "abc");
250 (void) strncpy(one, "xyz", 0); /* Zero-length copy. */
251 equal(one, "abc", 10);
252
253 (void) strncpy(one, "", 2); /* Zero-length source. */
254 equal(one, "", 11);
255 equal(one+1, "", 12);
256 equal(one+2, "c", 13);
257
258 (void) strcpy(one, "hi there");
259 (void) strncpy(two, one, 9);
260 equal(two, "hi there", 14); /* Just paranoia. */
261 equal(one, "hi there", 15); /* Stomped on source? */
262
263 /*
264 * strlen
265 */
266 it = "strlen";
267 check(strlen("") == 0, 1); /* Empty. */
268 check(strlen("a") == 1, 2); /* Single char. */
269 check(strlen("abcd") == 4, 3); /* Multiple chars. */
270
271 /*
272 * strchr
273 */
274 it = "strchr";
275 check(strchr("abcd", 'z') == NULL, 1); /* Not found. */
276 (void) strcpy(one, "abcd");
277 check(strchr(one, 'c') == one+2, 2); /* Basic test. */
278 check(strchr(one, 'd') == one+3, 3); /* End of string. */
279 check(strchr(one, 'a') == one, 4); /* Beginning. */
280 check(strchr(one, '\0') == one+4, 5); /* Finding NUL. */
281 (void) strcpy(one, "ababa");
282 check(strchr(one, 'b') == one+1, 6); /* Finding first. */
283 (void) strcpy(one, "");
284 check(strchr(one, 'b') == NULL, 7); /* Empty string. */
285 check(strchr(one, '\0') == one, 8); /* NUL in empty string. */
286
287 /*
288 * index - just like strchr
289 */
290 it = "index";
291 check(index("abcd", 'z') == NULL, 1); /* Not found. */
292 (void) strcpy(one, "abcd");
293 check(index(one, 'c') == one+2, 2); /* Basic test. */
294 check(index(one, 'd') == one+3, 3); /* End of string. */
295 check(index(one, 'a') == one, 4); /* Beginning. */
296 check(index(one, '\0') == one+4, 5); /* Finding NUL. */
297 (void) strcpy(one, "ababa");
298 check(index(one, 'b') == one+1, 6); /* Finding first. */
299 (void) strcpy(one, "");
300 check(index(one, 'b') == NULL, 7); /* Empty string. */
301 check(index(one, '\0') == one, 8); /* NUL in empty string. */
302
303 /*
304 * strrchr
305 */
306 it = "strrchr";
307 check(strrchr("abcd", 'z') == NULL, 1); /* Not found. */
308 (void) strcpy(one, "abcd");
309 check(strrchr(one, 'c') == one+2, 2); /* Basic test. */
310 check(strrchr(one, 'd') == one+3, 3); /* End of string. */
311 check(strrchr(one, 'a') == one, 4); /* Beginning. */
312 check(strrchr(one, '\0') == one+4, 5); /* Finding NUL. */
313 (void) strcpy(one, "ababa");
314 check(strrchr(one, 'b') == one+3, 6); /* Finding last. */
315 (void) strcpy(one, "");
316 check(strrchr(one, 'b') == NULL, 7); /* Empty string. */
317 check(strrchr(one, '\0') == one, 8); /* NUL in empty string. */
318
319 /*
320 * rindex - just like strrchr
321 */
322 it = "rindex";
323 check(rindex("abcd", 'z') == NULL, 1); /* Not found. */
324 (void) strcpy(one, "abcd");
325 check(rindex(one, 'c') == one+2, 2); /* Basic test. */
326 check(rindex(one, 'd') == one+3, 3); /* End of string. */
327 check(rindex(one, 'a') == one, 4); /* Beginning. */
328 check(rindex(one, '\0') == one+4, 5); /* Finding NUL. */
329 (void) strcpy(one, "ababa");
330 check(rindex(one, 'b') == one+3, 6); /* Finding last. */
331 (void) strcpy(one, "");
332 check(rindex(one, 'b') == NULL, 7); /* Empty string. */
333 check(rindex(one, '\0') == one, 8); /* NUL in empty string. */
334 }
335
second()336 second()
337 {
338 /*
339 * strpbrk - somewhat like strchr
340 */
341 it = "strpbrk";
342 check(strpbrk("abcd", "z") == NULL, 1); /* Not found. */
343 (void) strcpy(one, "abcd");
344 check(strpbrk(one, "c") == one+2, 2); /* Basic test. */
345 check(strpbrk(one, "d") == one+3, 3); /* End of string. */
346 check(strpbrk(one, "a") == one, 4); /* Beginning. */
347 check(strpbrk(one, "") == NULL, 5); /* Empty search list. */
348 check(strpbrk(one, "cb") == one+1, 6); /* Multiple search. */
349 (void) strcpy(one, "abcabdea");
350 check(strpbrk(one, "b") == one+1, 7); /* Finding first. */
351 check(strpbrk(one, "cb") == one+1, 8); /* With multiple search. */
352 check(strpbrk(one, "db") == one+1, 9); /* Another variant. */
353 (void) strcpy(one, "");
354 check(strpbrk(one, "bc") == NULL, 10); /* Empty string. */
355 check(strpbrk(one, "") == NULL, 11); /* Both strings empty. */
356
357 #if 0
358 /*
359 * strstr - somewhat like strchr
360 */
361 it = "strstr";
362 check(strstr("abcd", "z") == NULL, 1); /* Not found. */
363 check(strstr("abcd", "abx") == NULL, 2); /* Dead end. */
364 (void) strcpy(one, "abcd");
365 check(strstr(one, "c") == one+2, 3); /* Basic test. */
366 check(strstr(one, "bc") == one+1, 4); /* Multichar. */
367 check(strstr(one, "d") == one+3, 5); /* End of string. */
368 check(strstr(one, "cd") == one+2, 6); /* Tail of string. */
369 check(strstr(one, "abc") == one, 7); /* Beginning. */
370 check(strstr(one, "abcd") == one, 8); /* Exact match. */
371 check(strstr(one, "abcde") == NULL, 9); /* Too long. */
372 check(strstr(one, "de") == NULL, 10); /* Past end. */
373 check(strstr(one, "") == one+4, 11); /* Finding empty. */
374 (void) strcpy(one, "ababa");
375 check(strstr(one, "ba") == one+1, 12); /* Finding first. */
376 (void) strcpy(one, "");
377 check(strstr(one, "b") == NULL, 13); /* Empty string. */
378 check(strstr(one, "") == one, 14); /* Empty in empty string. */
379 (void) strcpy(one, "bcbca");
380 check(strstr(one, "bca") == one+2, 15); /* False start. */
381 (void) strcpy(one, "bbbcabbca");
382 check(strstr(one, "bbca") == one+1, 16); /* With overlap. */
383 #endif
384
385 /*
386 * strspn
387 */
388 it = "strspn";
389 check(strspn("abcba", "abc") == 5, 1); /* Whole string. */
390 check(strspn("abcba", "ab") == 2, 2); /* Partial. */
391 check(strspn("abc", "qx") == 0, 3); /* None. */
392 check(strspn("", "ab") == 0, 4); /* Null string. */
393 check(strspn("abc", "") == 0, 5); /* Null search list. */
394
395 /*
396 * strcspn
397 */
398 it = "strcspn";
399 check(strcspn("abcba", "qx") == 5, 1); /* Whole string. */
400 check(strcspn("abcba", "cx") == 2, 2); /* Partial. */
401 check(strcspn("abc", "abc") == 0, 3); /* None. */
402 check(strcspn("", "ab") == 0, 4); /* Null string. */
403 check(strcspn("abc", "") == 3, 5); /* Null search list. */
404
405 /*
406 * strtok - the hard one
407 */
408 it = "strtok";
409 (void) strcpy(one, "first, second, third");
410 equal(strtok(one, ", "), "first", 1); /* Basic test. */
411 equal(one, "first", 2);
412 equal(strtok((char *)NULL, ", "), "second", 3);
413 equal(strtok((char *)NULL, ", "), "third", 4);
414 check(strtok((char *)NULL, ", ") == NULL, 5);
415 (void) strcpy(one, ", first, ");
416 equal(strtok(one, ", "), "first", 6); /* Extra delims, 1 tok. */
417 check(strtok((char *)NULL, ", ") == NULL, 7);
418 (void) strcpy(one, "1a, 1b; 2a, 2b");
419 equal(strtok(one, ", "), "1a", 8); /* Changing delim lists. */
420 equal(strtok((char *)NULL, "; "), "1b", 9);
421 equal(strtok((char *)NULL, ", "), "2a", 10);
422 (void) strcpy(two, "x-y");
423 equal(strtok(two, "-"), "x", 11); /* New string before done. */
424 equal(strtok((char *)NULL, "-"), "y", 12);
425 check(strtok((char *)NULL, "-") == NULL, 13);
426 (void) strcpy(one, "a,b, c,, ,d");
427 equal(strtok(one, ", "), "a", 14); /* Different separators. */
428 equal(strtok((char *)NULL, ", "), "b", 15);
429 equal(strtok((char *)NULL, " ,"), "c", 16); /* Permute list too. */
430 equal(strtok((char *)NULL, " ,"), "d", 17);
431 check(strtok((char *)NULL, ", ") == NULL, 18);
432 check(strtok((char *)NULL, ", ") == NULL, 19); /* Persistence. */
433 (void) strcpy(one, ", ");
434 check(strtok(one, ", ") == NULL, 20); /* No tokens. */
435 (void) strcpy(one, "");
436 check(strtok(one, ", ") == NULL, 21); /* Empty string. */
437 (void) strcpy(one, "abc");
438 equal(strtok(one, ", "), "abc", 22); /* No delimiters. */
439 check(strtok((char *)NULL, ", ") == NULL, 23);
440 (void) strcpy(one, "abc");
441 equal(strtok(one, ""), "abc", 24); /* Empty delimiter list. */
442 check(strtok((char *)NULL, "") == NULL, 25);
443 (void) strcpy(one, "abcdefgh");
444 (void) strcpy(one, "a,b,c");
445 equal(strtok(one, ","), "a", 26); /* Basics again... */
446 equal(strtok((char *)NULL, ","), "b", 27);
447 equal(strtok((char *)NULL, ","), "c", 28);
448 check(strtok((char *)NULL, ",") == NULL, 29);
449 equal(one+6, "gh", 30); /* Stomped past end? */
450 equal(one, "a", 31); /* Stomped old tokens? */
451 equal(one+2, "b", 32);
452 equal(one+4, "c", 33);
453
454 /*
455 * memcmp
456 */
457 it = "memcmp";
458 check(memcmp("a", "a", 1) == 0, 1); /* Identity. */
459 check(memcmp("abc", "abc", 3) == 0, 2); /* Multicharacter. */
460 check(memcmp("abcd", "abce", 4) < 0, 3); /* Honestly unequal. */
461 check(memcmp("abce", "abcd", 4) > 0, 4);
462 check(memcmp("alph", "beta", 4) < 0, 5);
463 if (charsigned) /* Sign-bit comparison. */
464 check(memcmp("a\203", "a\003", 2) < 0, 6);
465 else
466 check(memcmp("a\203", "a\003", 2) > 0, 6);
467 check(memcmp("abce", "abcd", 3) == 0, 7); /* Count limited. */
468 check(memcmp("abc", "def", 0) == 0, 8); /* Zero count. */
469
470 /*
471 * memchr
472 */
473 it = "memchr";
474 check(memchr("abcd", 'z', 4) == NULL, 1); /* Not found. */
475 (void) strcpy(one, "abcd");
476 check(memchr(one, 'c', 4) == one+2, 2); /* Basic test. */
477 check(memchr(one, 'd', 4) == one+3, 3); /* End of string. */
478 check(memchr(one, 'a', 4) == one, 4); /* Beginning. */
479 check(memchr(one, '\0', 5) == one+4, 5); /* Finding NUL. */
480 (void) strcpy(one, "ababa");
481 check(memchr(one, 'b', 5) == one+1, 6); /* Finding first. */
482 check(memchr(one, 'b', 0) == NULL, 7); /* Zero count. */
483 check(memchr(one, 'a', 1) == one, 8); /* Singleton case. */
484 (void) strcpy(one, "a\203b");
485 check(memchr(one, 0203, 3) == one+1, 9); /* Unsignedness. */
486
487 /*
488 * memcpy
489 *
490 * Note that X3J11 says memcpy must work regardless of overlap.
491 * The SVID says it might fail.
492 */
493 it = "memcpy";
494 check(memcpy(one, "abc", 4) == one, 1); /* Returned value. */
495 equal(one, "abc", 2); /* Did the copy go right? */
496
497 (void) strcpy(one, "abcdefgh");
498 (void) memcpy(one+1, "xyz", 2);
499 equal(one, "axydefgh", 3); /* Basic test. */
500
501 (void) strcpy(one, "abc");
502 (void) memcpy(one, "xyz", 0);
503 equal(one, "abc", 4); /* Zero-length copy. */
504
505 (void) strcpy(one, "hi there");
506 (void) strcpy(two, "foo");
507 (void) memcpy(two, one, 9);
508 equal(two, "hi there", 5); /* Just paranoia. */
509 equal(one, "hi there", 6); /* Stomped on source? */
510
511 (void) strcpy(one, "abcdefgh");
512 (void) memcpy(one+1, one, 9);
513 equal(one, "aabcdefgh", 7); /* Overlap, right-to-left. */
514
515 (void) strcpy(one, "abcdefgh");
516 (void) memcpy(one+1, one+2, 7);
517 equal(one, "acdefgh", 8); /* Overlap, left-to-right. */
518
519 (void) strcpy(one, "abcdefgh");
520 (void) memcpy(one, one, 9);
521 equal(one, "abcdefgh", 9); /* 100% overlap. */
522
523 /*
524 * memccpy - first test like memcpy, then the search part
525 *
526 * The SVID, the only place where memccpy is mentioned, says
527 * overlap might fail, so we don't try it. Besides, it's hard
528 * to see the rationale for a non-left-to-right memccpy.
529 */
530 it = "memccpy";
531 check(memccpy(one, "abc", 'q', 4) == NULL, 1); /* Returned value. */
532 equal(one, "abc", 2); /* Did the copy go right? */
533
534 (void) strcpy(one, "abcdefgh");
535 (void) memccpy(one+1, "xyz", 'q', 2);
536 equal(one, "axydefgh", 3); /* Basic test. */
537
538 (void) strcpy(one, "abc");
539 (void) memccpy(one, "xyz", 'q', 0);
540 equal(one, "abc", 4); /* Zero-length copy. */
541
542 (void) strcpy(one, "hi there");
543 (void) strcpy(two, "foo");
544 (void) memccpy(two, one, 'q', 9);
545 equal(two, "hi there", 5); /* Just paranoia. */
546 equal(one, "hi there", 6); /* Stomped on source? */
547
548 (void) strcpy(one, "abcdefgh");
549 (void) strcpy(two, "horsefeathers");
550 check(memccpy(two, one, 'f', 9) == two+6, 7); /* Returned value. */
551 equal(one, "abcdefgh", 8); /* Source intact? */
552 equal(two, "abcdefeathers", 9); /* Copy correct? */
553
554 (void) strcpy(one, "abcd");
555 (void) strcpy(two, "bumblebee");
556 check(memccpy(two, one, 'a', 4) == two+1, 10); /* First char. */
557 equal(two, "aumblebee", 11);
558 check(memccpy(two, one, 'd', 4) == two+4, 12); /* Last char. */
559 equal(two, "abcdlebee", 13);
560 (void) strcpy(one, "xyz");
561 check(memccpy(two, one, 'x', 1) == two+1, 14); /* Singleton. */
562 equal(two, "xbcdlebee", 15);
563
564 /*
565 * memset
566 */
567 it = "memset";
568 (void) strcpy(one, "abcdefgh");
569 check(memset(one+1, 'x', 3) == one+1, 1); /* Return value. */
570 equal(one, "axxxefgh", 2); /* Basic test. */
571
572 (void) memset(one+2, 'y', 0);
573 equal(one, "axxxefgh", 3); /* Zero-length set. */
574
575 (void) memset(one+5, 0, 1);
576 equal(one, "axxxe", 4); /* Zero fill. */
577 equal(one+6, "gh", 5); /* And the leftover. */
578
579 (void) memset(one+2, 010045, 1);
580 equal(one, "ax\045xe", 6); /* Unsigned char convert. */
581
582 /*
583 * bcopy - much like memcpy
584 *
585 * Berklix manual is silent about overlap, so don't test it.
586 */
587 it = "bcopy";
588 (void) bcopy("abc", one, 4);
589 equal(one, "abc", 1); /* Simple copy. */
590
591 (void) strcpy(one, "abcdefgh");
592 (void) bcopy("xyz", one+1, 2);
593 equal(one, "axydefgh", 2); /* Basic test. */
594
595 (void) strcpy(one, "abc");
596 (void) bcopy("xyz", one, 0);
597 equal(one, "abc", 3); /* Zero-length copy. */
598
599 (void) strcpy(one, "hi there");
600 (void) strcpy(two, "foo");
601 (void) bcopy(one, two, 9);
602 equal(two, "hi there", 4); /* Just paranoia. */
603 equal(one, "hi there", 5); /* Stomped on source? */
604
605 /*
606 * bzero
607 */
608 it = "bzero";
609 (void) strcpy(one, "abcdef");
610 bzero(one+2, 2);
611 equal(one, "ab", 1); /* Basic test. */
612 equal(one+3, "", 2);
613 equal(one+4, "ef", 3);
614
615 (void) strcpy(one, "abcdef");
616 bzero(one+2, 0);
617 equal(one, "abcdef", 4); /* Zero-length copy. */
618
619 /*
620 * bcmp - somewhat like memcmp
621 */
622 it = "bcmp";
623 check(bcmp("a", "a", 1) == 0, 1); /* Identity. */
624 check(bcmp("abc", "abc", 3) == 0, 2); /* Multicharacter. */
625 check(bcmp("abcd", "abce", 4) != 0, 3); /* Honestly unequal. */
626 check(bcmp("abce", "abcd", 4) != 0, 4);
627 check(bcmp("alph", "beta", 4) != 0, 5);
628 check(bcmp("abce", "abcd", 3) == 0, 6); /* Count limited. */
629 check(bcmp("abc", "def", 0) == 0, 8); /* Zero count. */
630
631 #ifdef ERR
632 /*
633 * strerror - VERY system-dependent
634 */
635 it = "strerror";
636 f = open("/", 1); /* Should always fail. */
637 check(f < 0 && errno > 0 && errno < sys_nerr, 1);
638 equal(strerror(errno), sys_errlist[errno], 2);
639 #ifdef UNIXERR
640 equal(strerror(errno), "Is a directory", 3);
641 #endif
642 #ifdef BERKERR
643 equal(strerror(errno), "Permission denied", 3);
644 #endif
645 #endif
646 }
647