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