fdwalk should return 0 on an empty directory
[kopensolaris-gnu/glibc.git] / malloc / tst-calloc.c
1 /* Copyright (C) 2000, 2002 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Ulrich Drepper <drepper@redhat.com>.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #include <errno.h>
21 #include <error.h>
22 #include <limits.h>
23 #include <malloc.h>
24 #include <stdlib.h>
25 #include <stdio.h>
26
27
28 /* Number of samples per size.  */
29 #define N 50000
30
31
32 static void
33 fixed_test (int size)
34 {
35   char *ptrs[N];
36   int i;
37
38   for (i = 0; i < N; ++i)
39     {
40       int j;
41
42       ptrs[i] = (char *) calloc (1, size);
43
44       if (ptrs[i] == NULL)
45         break;
46
47       for (j = 0; j < size; ++j)
48         {
49           if (ptrs[i][j] != '\0')
50             error (EXIT_FAILURE, 0,
51                    "byte not cleared (size %d, element %d, byte %d)",
52                    size, i, j);
53           ptrs[i][j] = '\xff';
54         }
55     }
56
57   while (i-- > 0)
58     free (ptrs[i]);
59 }
60
61
62 static void
63 random_test (void)
64 {
65   char *ptrs[N];
66   int i;
67
68   for (i = 0; i < N; ++i)
69     {
70       int j;
71       int n = 1 + random () % 10;
72       int elem = 1 + random () % 100;
73       int size = n * elem;
74
75       ptrs[i] = (char *) calloc (n, elem);
76
77       if (ptrs[i] == NULL)
78         break;
79
80       for (j = 0; j < size; ++j)
81         {
82           if (ptrs[i][j] != '\0')
83             error (EXIT_FAILURE, 0,
84                    "byte not cleared (size %d, element %d, byte %d)",
85                    size, i, j);
86           ptrs[i][j] = '\xff';
87         }
88     }
89
90   while (i-- > 0)
91     free (ptrs[i]);
92 }
93
94
95 static void
96 null_test (void)
97 {
98   /* If the size is 0 the result is implementation defined.  Just make
99      sure the program doesn't crash.  */
100   calloc (0, 0);
101   calloc (0, UINT_MAX);
102   calloc (UINT_MAX, 0);
103   calloc (0, ~((size_t) 0));
104   calloc (~((size_t) 0), 0);
105 }
106
107
108 int
109 main (void)
110 {
111   /* We are allocating blocks with `calloc' and check whether every
112      block is completely cleared.  We first try this for some fixed
113      times and then with random size.  */
114   fixed_test (15);
115   fixed_test (5);
116   fixed_test (17);
117   fixed_test (6);
118   fixed_test (31);
119   fixed_test (96);
120
121   random_test ();
122
123   null_test ();
124
125   return 0;
126 }