OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [newlib-1.17.0/] [newlib/] [libm/] [test/] [string.c] - Blame information for rev 864

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.