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 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
