1 /*
2 * Copyright (c) International Business Machines Corp., 2004
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12 * the 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 to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 /*
20 * TEST CASE : config.c
21 *
22 * VARIATIONS : 28
23 *
24 * API'S TESTED : dm_get_config
25 */
26 #include <string.h>
27 #include <stdio.h>
28 #include <errno.h>
29 #include <fcntl.h>
30 #include <unistd.h>
31 #include <sys/stat.h>
32 #include "dm_test.h"
33
main(int argc,char ** argv)34 int main(int argc, char **argv)
35 {
36
37 char *szFuncName;
38 char *varstr;
39 int rc;
40 int i;
41
42 DMOPT_PARSE(argc, argv);
43 DMLOG_START();
44
45 /* CANNOT DO ANYTHING WITHOUT SUCCESSFUL INITIALIZATION AND NO PREEXISTING FILES!!! */
46 if ((rc = dm_init_service(&varstr)) != 0) {
47 DMLOG_PRINT(DMLVL_ERR,
48 "dm_init_service failed! (rc = %d, errno = %d)\n",
49 rc, errno);
50 DM_EXIT();
51 }
52
53 DMLOG_PRINT(DMLVL_DEBUG, "Starting DMAPI configuration tests\n");
54
55 szFuncName = "dm_get_config";
56
57 /*
58 * TEST : dm_get_config - invalid hanp
59 * EXPECTED: rc = -1, errno = EFAULT
60 */
61 if (DMVAR_EXEC(GET_CONFIG_BASE + 1)) {
62 int fd;
63 void *hanp;
64 size_t hlen;
65 dm_size_t retval;
66
67 /* Variation set up */
68 if ((fd =
69 open(DUMMY_FILE, O_RDWR | O_CREAT,
70 DUMMY_FILE_RW_MODE)) == -1) {
71 /* No clean up */
72 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
73 close(fd);
74 remove(DUMMY_FILE);
75 }
76 if (fd == -1 || rc == -1) {
77 DMLOG_PRINT(DMLVL_DEBUG,
78 "Unable to set up variation! (errno = %d)\n",
79 errno);
80 DMVAR_SKIP();
81 } else {
82 /* Variation */
83 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hanp)\n",
84 szFuncName);
85 rc = dm_get_config((void *)INVALID_ADDR, hlen,
86 DM_CONFIG_BULKALL, &retval);
87 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT);
88
89 /* Variation clean up */
90 rc = close(fd);
91 rc |= remove(DUMMY_FILE);
92 if (rc == -1) {
93 DMLOG_PRINT(DMLVL_DEBUG,
94 "Unable to clean up variation! (errno = %d)\n",
95 errno);
96 }
97 dm_handle_free(hanp, hlen);
98 }
99 }
100
101 /*
102 * TEST : dm_get_config - invalid hlen
103 * EXPECTED: rc = -1, errno = EBADF
104 */
105 if (DMVAR_EXEC(GET_CONFIG_BASE + 2)) {
106 int fd;
107 void *hanp;
108 size_t hlen;
109 dm_size_t retval;
110
111 /* Variation set up */
112 if ((fd =
113 open(DUMMY_FILE, O_RDWR | O_CREAT,
114 DUMMY_FILE_RW_MODE)) == -1) {
115 /* No clean up */
116 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
117 close(fd);
118 remove(DUMMY_FILE);
119 }
120 if (fd == -1 || rc == -1) {
121 DMLOG_PRINT(DMLVL_DEBUG,
122 "Unable to set up variation! (errno = %d)\n",
123 errno);
124 DMVAR_SKIP();
125 } else {
126 /* Variation */
127 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid hlen)\n",
128 szFuncName);
129 rc = dm_get_config(hanp, INVALID_ADDR,
130 DM_CONFIG_BULKALL, &retval);
131 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF);
132
133 /* Variation clean up */
134 rc = close(fd);
135 rc |= remove(DUMMY_FILE);
136 if (rc == -1) {
137 DMLOG_PRINT(DMLVL_DEBUG,
138 "Unable to clean up variation! (errno = %d)\n",
139 errno);
140 }
141 dm_handle_free(hanp, hlen);
142 }
143 }
144
145 /*
146 * TEST : dm_get_config - invalid flagname
147 * EXPECTED: rc = -1, errno = EINVAL
148 */
149 if (DMVAR_EXEC(GET_CONFIG_BASE + 3)) {
150 int fd;
151 void *hanp;
152 size_t hlen;
153 dm_size_t retval;
154
155 /* Variation set up */
156 if ((fd =
157 open(DUMMY_FILE, O_RDWR | O_CREAT,
158 DUMMY_FILE_RW_MODE)) == -1) {
159 /* No clean up */
160 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
161 close(fd);
162 remove(DUMMY_FILE);
163 }
164 if (fd == -1 || rc == -1) {
165 DMLOG_PRINT(DMLVL_DEBUG,
166 "Unable to set up variation! (errno = %d)\n",
167 errno);
168 DMVAR_SKIP();
169 } else {
170 /* Variation */
171 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid flagname)\n",
172 szFuncName);
173 rc = dm_get_config(hanp, hlen, INVALID_ADDR, &retval);
174 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EINVAL);
175
176 /* Variation clean up */
177 rc = close(fd);
178 rc |= remove(DUMMY_FILE);
179 if (rc == -1) {
180 DMLOG_PRINT(DMLVL_DEBUG,
181 "Unable to clean up variation! (errno = %d)\n",
182 errno);
183 }
184 dm_handle_free(hanp, hlen);
185 }
186 }
187
188 /*
189 * TEST : dm_get_config - invalid retvalp
190 * EXPECTED: rc = -1, errno = EFAULT
191 */
192 if (DMVAR_EXEC(GET_CONFIG_BASE + 4)) {
193 int fd;
194 void *hanp;
195 size_t hlen;
196
197 /* Variation set up */
198 if ((fd =
199 open(DUMMY_FILE, O_RDWR | O_CREAT,
200 DUMMY_FILE_RW_MODE)) == -1) {
201 /* No clean up */
202 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
203 close(fd);
204 remove(DUMMY_FILE);
205 }
206 if (fd == -1 || rc == -1) {
207 DMLOG_PRINT(DMLVL_DEBUG,
208 "Unable to set up variation! (errno = %d)\n",
209 errno);
210 DMVAR_SKIP();
211 } else {
212 /* Variation */
213 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalid retvalp)\n",
214 szFuncName);
215 rc = dm_get_config(hanp, hlen, DM_CONFIG_BULKALL,
216 (dm_size_t *) INVALID_ADDR);
217 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EFAULT);
218
219 /* Variation clean up */
220 rc = close(fd);
221 rc |= remove(DUMMY_FILE);
222 if (rc == -1) {
223 DMLOG_PRINT(DMLVL_DEBUG,
224 "Unable to clean up variation! (errno = %d)\n",
225 errno);
226 }
227 dm_handle_free(hanp, hlen);
228 }
229 }
230
231 /*
232 * TEST : dm_get_config - global handle
233 * EXPECTED: rc = -1, errno = EBADF
234 */
235 if (DMVAR_EXEC(GET_CONFIG_BASE + 5)) {
236 dm_size_t retval;
237
238 /* Variation set up */
239
240 /* Variation */
241 DMLOG_PRINT(DMLVL_DEBUG, "%s(global handle)\n", szFuncName);
242 rc = dm_get_config(DM_GLOBAL_HANP, DM_GLOBAL_HLEN,
243 DM_CONFIG_BULKALL, &retval);
244 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF);
245
246 /* Variation clean up */
247 }
248
249 /*
250 * TEST : dm_get_config - file handle
251 * EXPECTED: rc = 0
252 */
253 if (DMVAR_EXEC(GET_CONFIG_BASE + 6)) {
254 int fd;
255 void *hanp;
256 size_t hlen;
257 dm_size_t retval;
258
259 /* Variation set up */
260 if ((fd =
261 open(DUMMY_FILE, O_RDWR | O_CREAT,
262 DUMMY_FILE_RW_MODE)) == -1) {
263 /* No clean up */
264 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
265 close(fd);
266 remove(DUMMY_FILE);
267 }
268 if (fd == -1 || rc == -1) {
269 DMLOG_PRINT(DMLVL_DEBUG,
270 "Unable to set up variation! (errno = %d)\n",
271 errno);
272 DMVAR_SKIP();
273 } else {
274 /* Variation */
275 DMLOG_PRINT(DMLVL_DEBUG, "%s(file handle)\n",
276 szFuncName);
277 rc = dm_get_config(hanp, hlen, DM_CONFIG_BULKALL,
278 &retval);
279 DMVAR_ENDPASSEXP(szFuncName, 0, rc);
280
281 /* Variation clean up */
282 rc = close(fd);
283 rc |= remove(DUMMY_FILE);
284 if (rc == -1) {
285 DMLOG_PRINT(DMLVL_DEBUG,
286 "Unable to clean up variation! (errno = %d)\n",
287 errno);
288 }
289 dm_handle_free(hanp, hlen);
290 }
291 }
292
293 /*
294 * TEST : dm_get_config - directory handle
295 * EXPECTED: rc = 0
296 */
297 if (DMVAR_EXEC(GET_CONFIG_BASE + 7)) {
298 int fd;
299 void *hanp;
300 size_t hlen;
301 dm_size_t retval;
302
303 /* Variation set up */
304 if ((rc = mkdir(DUMMY_SUBDIR, DUMMY_DIR_RW_MODE)) == -1) {
305 /* No clean up */
306 } else if ((rc = dm_path_to_handle(DUMMY_SUBDIR, &hanp, &hlen))
307 == -1) {
308 rmdir(DUMMY_SUBDIR);
309 }
310 if (fd == -1 || rc == -1) {
311 DMLOG_PRINT(DMLVL_DEBUG,
312 "Unable to set up variation! (errno = %d)\n",
313 errno);
314 DMVAR_SKIP();
315 } else {
316 /* Variation */
317 DMLOG_PRINT(DMLVL_DEBUG, "%s(dir handle)\n",
318 szFuncName);
319 rc = dm_get_config(hanp, hlen, DM_CONFIG_BULKALL,
320 &retval);
321 DMVAR_ENDPASSEXP(szFuncName, 0, rc);
322
323 /* Variation clean up */
324 rc = rmdir(DUMMY_SUBDIR);
325 if (rc == -1) {
326 DMLOG_PRINT(DMLVL_DEBUG,
327 "Unable to clean up variation! (errno = %d)\n",
328 errno);
329 }
330 dm_handle_free(hanp, hlen);
331 }
332 }
333
334 /*
335 * TEST : dm_get_config - fs handle
336 * EXPECTED: rc = 0
337 */
338 if (DMVAR_EXEC(GET_CONFIG_BASE + 8)) {
339 int fd;
340 void *hanp;
341 size_t hlen;
342 dm_size_t retval;
343
344 /* Variation set up */
345 if ((fd =
346 open(DUMMY_FILE, O_RDWR | O_CREAT,
347 DUMMY_FILE_RW_MODE)) == -1) {
348 /* No clean up */
349 } else if ((rc = dm_path_to_fshandle(DUMMY_FILE, &hanp, &hlen))
350 == -1) {
351 close(fd);
352 remove(DUMMY_FILE);
353 }
354 if (fd == -1 || rc == -1) {
355 DMLOG_PRINT(DMLVL_DEBUG,
356 "Unable to set up variation! (errno = %d)\n",
357 errno);
358 DMVAR_SKIP();
359 } else {
360 /* Variation */
361 DMLOG_PRINT(DMLVL_DEBUG, "%s(fs handle)\n", szFuncName);
362 rc = dm_get_config(hanp, hlen, DM_CONFIG_BULKALL,
363 &retval);
364 DMVAR_ENDPASSEXP(szFuncName, 0, rc);
365
366 /* Variation clean up */
367 rc = close(fd);
368 rc |= remove(DUMMY_FILE);
369 if (rc == -1) {
370 DMLOG_PRINT(DMLVL_DEBUG,
371 "Unable to clean up variation! (errno = %d)\n",
372 errno);
373 }
374 dm_handle_free(hanp, hlen);
375 }
376 }
377
378 /*
379 * TEST : dm_get_config - invalidated handle
380 * EXPECTED: rc = -1, errno = EBADF
381 */
382 if (DMVAR_EXEC(GET_CONFIG_BASE + 9)) {
383 int fd;
384 void *hanp;
385 size_t hlen;
386 dm_size_t retval;
387
388 /* Variation set up */
389 if ((fd =
390 open(DUMMY_FILE, O_RDWR | O_CREAT,
391 DUMMY_FILE_RW_MODE)) == -1) {
392 /* No clean up */
393 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) == -1) {
394 close(fd);
395 remove(DUMMY_FILE);
396 } else if ((rc = close(fd)) == -1) {
397 dm_handle_free(hanp, hlen);
398 remove(DUMMY_FILE);
399 } else if ((rc = remove(DUMMY_FILE)) == -1) {
400 dm_handle_free(hanp, hlen);
401 }
402 if (fd == -1 || rc == -1) {
403 DMLOG_PRINT(DMLVL_DEBUG,
404 "Unable to set up variation! (errno = %d)\n",
405 errno);
406 DMVAR_SKIP();
407 } else {
408 /* Variation */
409 DMLOG_PRINT(DMLVL_DEBUG, "%s(invalidated handle)\n",
410 szFuncName);
411 rc = dm_get_config(hanp, hlen, DM_CONFIG_BULKALL,
412 &retval);
413 DMVAR_ENDFAILEXP(szFuncName, -1, rc, EBADF);
414
415 /* Variation clean up */
416 dm_handle_free(hanp, hlen);
417 }
418 }
419
420 /*
421 * TEST : dm_get_config
422 * EXPECTED: rc = 0
423 */
424 for (i = 1; i < CONFIG_MAX; i++) {
425 if (DMVAR_EXEC(GET_CONFIG_BASE + 9 + i)) {
426 int fd;
427 void *hanp;
428 size_t hlen;
429 dm_size_t retval;
430
431 /* Variation set up */
432 if ((fd =
433 open(DUMMY_FILE, O_RDWR | O_CREAT,
434 DUMMY_FILE_RW_MODE)) == -1) {
435 /* No clean up */
436 } else if ((rc = dm_fd_to_handle(fd, &hanp, &hlen)) ==
437 -1) {
438 close(fd);
439 remove(DUMMY_FILE);
440 }
441 if (fd == -1 || rc == -1) {
442 DMLOG_PRINT(DMLVL_DEBUG,
443 "Unable to set up variation! (errno = %d)\n",
444 errno);
445 DMVAR_SKIP();
446 } else {
447 /* Variation */
448 DMLOG_PRINT(DMLVL_DEBUG, "%s(%s)\n", szFuncName,
449 dmimpl_expectedResults[i].name);
450 rc = dm_get_config(hanp, hlen, i, &retval);
451 if (rc == 0) {
452 if (retval ==
453 dmimpl_expectedResults[i].result) {
454 DMLOG_PRINT(DMLVL_DEBUG,
455 "%s passed with expected rc = %d\n",
456 szFuncName, 0);
457 DMVAR_PASS();
458 } else {
459 DMLOG_PRINT(DMLVL_ERR,
460 "%s failed with expected rc = %d but unexpected retval (%lld vs %lld)\n",
461 szFuncName, 0,
462 retval,
463 dmimpl_expectedResults
464 [i].result);
465 DMVAR_FAIL();
466 }
467 } else {
468 DMLOG_PRINT(DMLVL_ERR,
469 "%s failed with unexpected rc = %d (errno = %d)\n",
470 szFuncName, rc, errno);
471 DMVAR_FAIL();
472 }
473
474 /* Variation clean up */
475 rc = close(fd);
476 rc |= remove(DUMMY_FILE);
477 if (rc == -1) {
478 DMLOG_PRINT(DMLVL_DEBUG,
479 "Unable to clean up variation! (errno = %d)\n",
480 errno);
481 }
482 dm_handle_free(hanp, hlen);
483 }
484 }
485 }
486
487 DMLOG_STOP();
488
489 tst_exit();
490
491 }
492