xfstests: some refinements on "make depend"
[xfstests-dev.git] / lib / databin.c
1 /*
2  * Copyright (c) 2000 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include <stdio.h>
19 #include <sys/param.h>
20 #include <string.h> /* memset */
21 #include <stdlib.h> /* rand */
22 #include "databin.h"
23
24 #if UNIT_TEST
25 #include <malloc.h>
26 #endif
27
28 static char Errmsg[80];
29
30 void
31 databingen (mode, buffer, bsize, offset)
32 int mode;       /* either a, c, r, o, z or C */
33 unsigned char *buffer;  /* buffer pointer */
34 int bsize;      /* size of buffer */
35 int offset;     /* offset into the file where buffer starts */
36 {
37 int ind;
38
39         switch (mode)
40         {
41         default:
42         case 'a':       /* alternating bit pattern */
43                 memset(buffer,0x55,bsize);
44                 break;
45
46         case 'c':       /* checkerboard pattern */
47                 memset(buffer,0xf0,bsize);
48                 break;
49
50         case 'C':       /* */
51                 for (ind=0;ind< bsize;ind++) {
52                     buffer[ind] = ((offset+ind)%8 & 0177);
53                 }
54                 break;
55
56         case 'o':
57                 memset(buffer,0xff,bsize);
58                 break;
59
60         case 'z':
61                 memset(buffer,0x0,bsize);
62                 break;
63
64         case 'r':       /* random */
65                 for (ind=0;ind< bsize;ind++) {
66                     buffer[ind] = (rand () & 0177) | 0100;
67                 }
68         }
69 }
70
71 /***********************************************************************
72  *
73  * return values:
74  *      >= 0 : error at byte offset into the file, offset+buffer[0-(bsize-1)]
75  *      < 0  : no error
76  ***********************************************************************/
77 int
78 databinchk(mode, buffer, bsize, offset, errmsg)
79 int mode;       /* either a, c, r, z, o, or C */
80 unsigned char *buffer;  /* buffer pointer */
81 int bsize;      /* size of buffer */
82 int offset;     /* offset into the file where buffer starts */
83 char **errmsg;
84 {
85         int cnt;
86         unsigned char *chr;
87         long expbits;
88         long actbits;
89
90         chr=buffer;
91
92         if ( errmsg != NULL ) {
93             *errmsg = Errmsg;
94         }
95         
96         switch (mode)
97         {
98         default:
99         case 'a':       /* alternating bit pattern */
100                 expbits=0x55;
101                 break;
102
103         case 'c':       /* checkerboard pattern */
104                 expbits=0xf0;
105                 break;
106
107         case 'C':       /* counting pattern */
108                 for (cnt=0;cnt< bsize;cnt++) {
109                     expbits = ((offset+cnt)%8 & 0177);
110
111                     if ( buffer[cnt] != expbits ) {
112                         sprintf(Errmsg,
113                             "data mismatch at offset %d, exp:%#lo, act:%#o",
114                             offset+cnt, expbits, buffer[cnt]);
115                         return offset+cnt;
116                     }
117                 }
118                 sprintf(Errmsg, "all %d bytes match desired pattern", bsize);
119                 return -1;
120
121         case 'o':
122                 expbits=0xff;
123                 break;
124
125         case 'z':
126                 expbits=0;
127                 break;
128
129         case 'r':
130                 return -1;      /* no check can be done for random */
131         }
132
133         for (cnt=0; cnt<bsize; chr++, cnt++) {
134             actbits = (long)*chr;
135
136             if ( actbits != expbits ) {
137                 sprintf(Errmsg, "data mismatch at offset %d, exp:%#lo, act:%#lo",
138                     offset+cnt, expbits, actbits);
139                 return offset+cnt;
140             }
141         }
142
143         sprintf(Errmsg, "all %d bytes match desired pattern", bsize);
144         return -1; /* all ok */
145 }
146
147 #if UNIT_TEST
148
149 /***********************************************************************
150  * main for doing unit testing
151  ***********************************************************************/
152 int
153 main(ac, ag)
154 int ac;
155 char **ag;
156 {
157
158     int size=1023;
159     int offset;
160     int number;
161     unsigned char *buffer;
162     int ret;
163     char *errmsg;
164
165     if ((buffer=(unsigned char *)malloc(size)) == NULL ) {
166         perror("malloc");
167         exit(2);
168     }
169
170
171 printf("***** for a ****************************\n");
172     databingen('a', buffer, size, 0);
173     printf("databingen('a', buffer, %d, 0)\n", size);
174
175     ret=databinchk('a', buffer, size, 0, &errmsg);
176     printf("databinchk('a', buffer, %d, 0, &errmsg) returned %d: %s\n",
177         size, ret, errmsg);
178     if ( ret == -1 )
179         printf("\tPASS return value of -1 as expected\n");
180     else
181         printf("\tFAIL return value %d, expected -1\n", ret);
182
183     offset=232400;
184     ret=databinchk('a', &buffer[1], size-1, offset, &errmsg);
185     printf("databinchk('a', &buffer[1], %d, %d, &errmsg) returned %d: %s\n",
186         size, offset, ret, errmsg);
187     if ( ret == -1 )
188         printf("\tPASS return value of -1 as expected\n");
189     else
190         printf("\tFAIL return value %d, expected -1\n", ret);
191
192     buffer[15]= 0x0;
193     printf("changing char 15 (offset (%d+15) = %d) to 0x0\n", offset, offset+15);
194     number=offset+15;
195
196     ret=databinchk('a', &buffer[1], size-1, offset+1, &errmsg);
197     printf("databinchk('a', &buffer[1], %d, %d, &errmsg) returned %d: %s\n",
198         size-1, offset+1, ret, errmsg);
199     if ( ret == number )
200         printf("\tPASS return value of %d as expected\n", number);
201     else
202         printf("\tFAIL return value %d, expected %d\n", ret, number);
203
204
205
206 printf("***** for c ****************************\n");
207     databingen('c', buffer, size, 0);
208     printf("databingen('c', buffer, %d, 0)\n", size);
209
210     ret=databinchk('c', buffer, size, 0, &errmsg);
211     printf("databinchk('c', buffer, %d, 0, &errmsg) returned %d: %s\n",
212         size, ret, errmsg);
213     if ( ret == -1 )
214         printf("\tPASS return value of -1 as expected\n");
215     else
216         printf("\tFAIL return value %d, expected -1\n", ret);
217
218     offset=232400;
219     ret=databinchk('c', &buffer[1], size-1, offset, &errmsg);
220     printf("databinchk('c', &buffer[1], %d, %d, &errmsg) returned %d: %s\n",
221         size, offset, ret, errmsg);
222     if ( ret == -1 )
223         printf("\tPASS return value of -1 as expected\n");
224     else
225         printf("\tFAIL return value %d, expected -1\n", ret);
226
227     buffer[15]= 0x0;
228     printf("changing char 15 (offset (%d+15) = %d) to 0x0\n", offset, offset+15);
229     number=offset+15;
230
231     ret=databinchk('c', &buffer[1], size-1, offset+1, &errmsg);
232     printf("databinchk('c', &buffer[1], %d, %d, &errmsg) returned %d: %s\n",
233         size-1, offset+1, ret, errmsg);
234     if ( ret == number )
235         printf("\tPASS return value of %d as expected\n", number);
236     else
237         printf("\tFAIL return value %d, expected %d\n", ret, number);
238
239 printf("***** for C ****************************\n");
240
241     databingen('C', buffer, size, 0);
242     printf("databingen('C', buffer, %d, 0)\n", size);
243
244     ret=databinchk('C', buffer, size, 0, &errmsg);
245     printf("databinchk('C', buffer, %d, 0, &errmsg) returned %d: %s\n",
246         size, ret, errmsg);
247     if ( ret == -1 )
248         printf("\tPASS return value of -1 as expected\n");
249     else
250         printf("\tFAIL return value %d, expected -1\n", ret);
251
252     offset=18;
253     ret=databinchk('C', &buffer[18], size-18, 18, &errmsg);
254     printf("databinchk('C', &buffer[18], %d, 18, &errmsg) returned %d: %s\n",
255         size-18, ret, errmsg);
256     if ( ret == -1 )
257         printf("\tPASS return value of -1 as expected\n");
258     else
259         printf("\tFAIL return value %d, expected -1\n", ret);
260
261     buffer[20]= 0x0;
262     buffer[21]= 0x0;
263     printf("changing char 20 and 21 to 0x0 (offset %d and %d)\n", 20,
264         21);
265
266     ret=databinchk('C', &buffer[18], size-18, 18, &errmsg);
267     printf("databinchk('C', &buffer[18], %d, 18, &errmsg) returned %d: %s\n",
268         size-18, ret, errmsg);
269
270     if ( ret == 20 || ret == 21 )
271         printf("\tPASS return value of %d or %d as expected\n",
272             20, 21);
273     else
274         printf("\tFAIL return value %d, expected %d or %d\n", ret,
275             20, 21 );
276
277     exit(0);
278
279 }
280
281 #endif
282