1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * diagcode library unit test
29 *
30 * usually run from "make test" target. takes a single argument
31 * which is the directory where the test dictionaries are found.
32 * this test driver scans the dictionaries for comments of the form:
33 * #TEST:<routine>:<errno>:<input>:<output>
34 * and executes that test.
35 *
36 * exit 0 and an "All tests passed" message means no failures. otherwise
37 * error messages are spewed as appropriate and exit value is non-zero.
38 */
39
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <ctype.h>
44 #include <alloca.h>
45 #include <errno.h>
46 #include <sys/types.h>
47 #include <dirent.h>
48 #include <stdarg.h>
49
50 #include <fm/diagcode.h>
51
52 #define MAXLINE 10240
53 #define MAXARG 10
54 #define MAXKEY 100
55 #define MAXCODE 100
56
57 static char *Myname;
58 static char *Dict;
59 static int Line;
60 static int Errcount;
61 static fm_dc_handle_t *Dhp;
62
63 /*PRINTFLIKE1*/
64 static void
err(const char * fmt,...)65 err(const char *fmt, ...)
66 {
67 va_list ap;
68
69 va_start(ap, fmt);
70 (void) fprintf(stderr, "%s: %s:%d ", Myname, Dict, Line);
71 (void) vfprintf(stderr, fmt, ap);
72 (void) fprintf(stderr, "\n");
73 Errcount++;
74 }
75
76 /* parse an expected errno value from test line (numeric or some symbolic) */
77 static int
geterrno(const char * s)78 geterrno(const char *s)
79 {
80 if (*s == '\0' || isspace(*s))
81 return (0);
82 else if (isdigit(*s))
83 return (atoi(s));
84 else if (strcmp(s, "EPERM") == 0)
85 return (EPERM);
86 else if (strcmp(s, "ENOENT") == 0)
87 return (ENOENT);
88 else if (strcmp(s, "ESRCH") == 0)
89 return (ESRCH);
90 else if (strcmp(s, "ENOMEM") == 0)
91 return (ENOMEM);
92 else if (strcmp(s, "EACCES") == 0)
93 return (EACCES);
94 else if (strcmp(s, "EINVAL") == 0)
95 return (EINVAL);
96 else if (strcmp(s, "ERANGE") == 0)
97 return (ERANGE);
98 else if (strcmp(s, "ENOMSG") == 0)
99 return (ENOMSG);
100 else if (strcmp(s, "ENOTSUP") == 0)
101 return (ENOTSUP);
102 else {
103 err("geterrno: don't know errno \"%s\"", s);
104 Errcount++;
105 return (0);
106 }
107 }
108
109 /* call fm_dc_opendict() as part of a test */
110 static void
do_open(const char * dirpath,const char * dictname,char * argv[],int argc)111 do_open(const char *dirpath, const char *dictname, char *argv[], int argc)
112 {
113 int reterrno;
114 int experrno;
115
116 if (argc != 2) {
117 err("argc != 2");
118 return;
119 }
120 experrno = geterrno(argv[1]);
121
122 if ((Dhp = fm_dc_opendict(FM_DC_VERSION, dirpath, dictname)) == NULL)
123 reterrno = errno;
124 else
125 reterrno = 0;
126
127 if (reterrno != experrno)
128 err("opendict errno %d, expected %d", reterrno, experrno);
129 }
130
131 /* call fm_dc_closedict() as part of a test */
132 static void
do_close(const char * dirpath,const char * dictname,char * argv[],int argc)133 do_close(const char *dirpath, const char *dictname, char *argv[], int argc)
134 {
135 if (Dhp) {
136 fm_dc_closedict(Dhp);
137 Dhp = NULL;
138 }
139 }
140
141 /* call fm_dc_codelen() as part of a test */
142 static void
do_codelen(const char * dirpath,const char * dictname,char * argv[],int argc)143 do_codelen(const char *dirpath, const char *dictname, char *argv[], int argc)
144 {
145 int retcodelen;
146 int expcodelen;
147
148 if (argc != 3) {
149 err("argc != 3");
150 return;
151 }
152 expcodelen = geterrno(argv[2]);
153
154 if (Dhp == NULL) {
155 err("codelen NULL handle");
156 return;
157 }
158
159 retcodelen = fm_dc_codelen(Dhp);
160
161 if (retcodelen != expcodelen)
162 err("codelen %d, expected %d", retcodelen, expcodelen);
163 }
164
165 /* call fm_dc_maxkey() as part of a test */
166 static void
do_maxkey(const char * dirpath,const char * dictname,char * argv[],int argc)167 do_maxkey(const char *dirpath, const char *dictname, char *argv[], int argc)
168 {
169 int retmaxkey;
170 int expmaxkey;
171
172 if (argc != 3) {
173 err("argc != 3");
174 return;
175 }
176 expmaxkey = geterrno(argv[2]);
177
178 if (Dhp == NULL) {
179 err("maxkey NULL handle");
180 return;
181 }
182
183 retmaxkey = fm_dc_maxkey(Dhp);
184
185 if (retmaxkey != expmaxkey)
186 err("maxkey %d, expected %d", retmaxkey, expmaxkey);
187 }
188
189 /* call fm_dc_key2code() as part of a test */
190 static void
do_key2code(const char * dirpath,const char * dictname,char * argv[],int argc)191 do_key2code(const char *dirpath, const char *dictname, char *argv[], int argc)
192 {
193 int reterrno;
194 int experrno;
195 const char *key[MAXKEY];
196 char code[MAXCODE];
197 int nel;
198 char *beginp;
199 char *endp;
200
201 if (argc < 3) {
202 err("argc < 3");
203 return;
204 }
205 if (argc > 4) {
206 err("argc > 4");
207 return;
208 }
209 experrno = geterrno(argv[1]);
210
211 /* convert key into array */
212 nel = 0;
213 beginp = argv[2];
214 while (nel < MAXKEY - 1) {
215 key[nel++] = beginp;
216 if ((endp = strchr(beginp, ' ')) != NULL) {
217 *endp++ = '\0';
218 beginp = endp;
219 } else
220 break;
221 }
222 key[nel] = NULL;
223
224 if (Dhp == NULL) {
225 err("key2code NULL handle");
226 return;
227 }
228
229 if (fm_dc_key2code(Dhp, key, code, MAXCODE) < 0)
230 reterrno = errno;
231 else
232 reterrno = 0;
233
234 if (reterrno != experrno) {
235 err("key2code errno %d, expected %d", reterrno, experrno);
236 return;
237 }
238
239 if (reterrno == 0 && argc > 3 && strcmp(code, argv[3]))
240 err("code \"%s\", expected \"%s\"", code, argv[3]);
241 }
242
243 /* call fm_dc_code2key() as part of a test */
244 static void
do_code2key(const char * dirpath,const char * dictname,char * argv[],int argc)245 do_code2key(const char *dirpath, const char *dictname, char *argv[], int argc)
246 {
247 int reterrno;
248 int experrno;
249 char keystr[MAXLINE];
250 char *key[MAXKEY];
251 int nel;
252
253 if (argc < 3) {
254 err("argc < 3");
255 return;
256 }
257 if (argc > 4) {
258 err("argc > 4");
259 return;
260 }
261 experrno = geterrno(argv[1]);
262
263 if (Dhp == NULL) {
264 err("code2key NULL handle");
265 return;
266 }
267
268 if (fm_dc_code2key(Dhp, argv[2], key, fm_dc_maxkey(Dhp)) < 0)
269 reterrno = errno;
270 else
271 reterrno = 0;
272
273 if (reterrno != experrno) {
274 err("errno %d, expected %d", reterrno, experrno);
275 return;
276 }
277
278 if (reterrno)
279 return;
280
281 if (argc > 3) {
282 /* convert key into string */
283 keystr[0] = '\0';
284 for (nel = 0; key[nel]; nel++) {
285 if (nel)
286 (void) strcat(keystr, " ");
287 (void) strcat(keystr, key[nel]);
288 }
289
290 if (strcmp(keystr, argv[3]))
291 err("key \"%s\", expected \"%s\"", keystr, argv[3]);
292 }
293 for (nel = 0; key[nel]; nel++)
294 free(key[nel]);
295 }
296
297 /* call fm_dc_getprop() as part of a test */
298 static void
do_getprop(const char * dirpath,const char * dictname,char * argv[],int argc)299 do_getprop(const char *dirpath, const char *dictname, char *argv[], int argc)
300 {
301 int reterrno;
302 int experrno;
303 const char *val;
304
305 if (argc != 4) {
306 err("argc != 4");
307 return;
308 }
309 experrno = geterrno(argv[1]);
310
311 if (Dhp == NULL) {
312 err("getprop NULL handle");
313 return;
314 }
315
316 if ((val = fm_dc_getprop(Dhp, argv[2])) == NULL)
317 reterrno = errno;
318 else
319 reterrno = 0;
320
321 if (reterrno != experrno) {
322 err("getprop errno %d, expected %d", reterrno, experrno);
323 return;
324 }
325
326 if (reterrno == 0 && strcmp(val, argv[3]))
327 err("val \"%s\", expected \"%s\"", val, argv[3]);
328 }
329
330 /* scan a dictionary, looking for test directives embedded in the comments */
331 static void
testdict(const char * dirpath,const char * dictname)332 testdict(const char *dirpath, const char *dictname)
333 {
334 char linebuf[MAXLINE];
335 char fname[MAXLINE];
336 FILE *fp;
337
338 (void) snprintf(fname, MAXLINE, "%s/%s.dict", dirpath, dictname);
339
340 if ((fp = fopen(fname, "r")) == NULL) {
341 perror(fname);
342 Errcount++;
343 return;
344 }
345
346 Line = 0;
347 Dict = fname;
348
349 while (fgets(linebuf, MAXLINE, fp) != NULL) {
350 char *argv[MAXARG];
351 int argc;
352 char *beginp;
353 char *endp;
354
355 Line++;
356 if (strncmp(linebuf, "#TEST:", 6))
357 continue;
358
359 if ((endp = strchr(linebuf, '\n')) != NULL)
360 *endp = '\0';
361 argc = 0;
362 beginp = &linebuf[6];
363 while (argc < MAXARG - 1) {
364 argv[argc++] = beginp;
365 if ((endp = strchr(beginp, ':')) != NULL) {
366 *endp++ = '\0';
367 beginp = endp;
368 } else
369 break;
370 }
371 argv[argc] = NULL;
372
373 if (strcmp(argv[0], "open") == 0)
374 do_open(dirpath, dictname, argv, argc);
375 else if (strcmp(argv[0], "close") == 0)
376 do_close(dirpath, dictname, argv, argc);
377 else if (strcmp(argv[0], "codelen") == 0)
378 do_codelen(dirpath, dictname, argv, argc);
379 else if (strcmp(argv[0], "maxkey") == 0)
380 do_maxkey(dirpath, dictname, argv, argc);
381 else if (strcmp(argv[0], "key2code") == 0)
382 do_key2code(dirpath, dictname, argv, argc);
383 else if (strcmp(argv[0], "code2key") == 0)
384 do_code2key(dirpath, dictname, argv, argc);
385 else if (strcmp(argv[0], "getprop") == 0)
386 do_getprop(dirpath, dictname, argv, argc);
387 else {
388 err("unknown TEST command: \"%s\"", argv[0]);
389 Errcount++;
390 }
391 }
392
393 (void) fclose(fp);
394
395 if (Dhp) {
396 fm_dc_closedict(Dhp);
397 Dhp = NULL;
398 }
399 }
400
401 /* scan a directory, looking for dictionaries to test against */
402 int
main(int argc,char * argv[])403 main(int argc, char *argv[])
404 {
405 DIR *dirp;
406 struct dirent *dp;
407
408 if ((Myname = strrchr(argv[0], '/')) == NULL)
409 Myname = argv[0];
410 else
411 Myname++;
412
413 if (argc != 2) {
414 (void) fprintf(stderr, "usage: %s test-directory\n", argv[0]);
415 exit(1);
416 }
417
418 if ((dirp = opendir(argv[1])) == NULL) {
419 perror(argv[1]);
420 exit(1);
421 }
422
423 while ((dp = readdir(dirp)) != NULL) {
424 char *ptr;
425
426 if (dp->d_name[0] == '.')
427 continue;
428
429 if ((ptr = strrchr(dp->d_name, '.')) == NULL ||
430 strcmp(ptr, ".dict"))
431 continue;
432
433 *ptr = '\0'; /* remove the extension */
434 testdict(argv[1], dp->d_name);
435 }
436 (void) closedir(dirp);
437
438 if (Errcount == 0)
439 (void) printf("%s: All tests passed.\n", Myname);
440
441 return (Errcount);
442 }
443