1 /*- 2 * Copyright (c) 2016 Adam Starak <starak.adam@gmail.com> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/cnv.h> 33 #include <sys/nv.h> 34 #include <sys/types.h> 35 36 #include <atf-c++.hpp> 37 #include <fcntl.h> 38 #include <errno.h> 39 40 #define fd_is_valid(fd) (fcntl((fd), F_GETFL) != -1 || errno != EBADF) 41 42 /* ATF cnvlist_get tests. */ 43 44 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_bool); 45 ATF_TEST_CASE_BODY(cnvlist_get_bool) 46 { 47 nvlist_t *nvl; 48 const char *key; 49 bool value; 50 void *cookie; 51 int type; 52 53 nvl = nvlist_create(0); 54 ATF_REQUIRE(nvl != NULL); 55 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 56 ATF_REQUIRE(nvlist_empty(nvl)); 57 58 cookie = NULL; 59 key = "name"; 60 value = true; 61 62 nvlist_add_bool(nvl, key, value); 63 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 64 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 65 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL); 66 ATF_REQUIRE(!nvlist_empty(nvl)); 67 ATF_REQUIRE(nvlist_exists(nvl, key)); 68 ATF_REQUIRE(nvlist_exists_bool(nvl, key)); 69 70 ATF_REQUIRE_EQ(cnvlist_get_bool(cookie), value); 71 72 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 73 static_cast<const char *>(NULL)); 74 75 nvlist_destroy(nvl); 76 } 77 78 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_number); 79 ATF_TEST_CASE_BODY(cnvlist_get_number) 80 { 81 nvlist_t *nvl; 82 const char *key; 83 uint64_t value; 84 void *cookie; 85 int type; 86 87 nvl = nvlist_create(0); 88 ATF_REQUIRE(nvl != NULL); 89 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 90 ATF_REQUIRE(nvlist_empty(nvl)); 91 92 cookie = NULL; 93 key = "name"; 94 value = 420; 95 96 nvlist_add_number(nvl, key, value); 97 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 98 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 99 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); 100 ATF_REQUIRE(!nvlist_empty(nvl)); 101 ATF_REQUIRE(nvlist_exists(nvl, key)); 102 ATF_REQUIRE(nvlist_exists_number(nvl, key)); 103 104 ATF_REQUIRE_EQ(cnvlist_get_number(cookie), value); 105 106 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 107 static_cast<const char *>(NULL)); 108 109 nvlist_destroy(nvl); 110 } 111 112 113 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_string); 114 ATF_TEST_CASE_BODY(cnvlist_get_string) 115 { 116 nvlist_t *nvl; 117 const char *key; 118 const char *value; 119 void *cookie; 120 int type; 121 122 nvl = nvlist_create(0); 123 ATF_REQUIRE(nvl != NULL); 124 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 125 ATF_REQUIRE(nvlist_empty(nvl)); 126 127 cookie = NULL; 128 key = "name"; 129 value = "text"; 130 131 nvlist_add_string(nvl, key, value); 132 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 133 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 134 ATF_REQUIRE_EQ(type, NV_TYPE_STRING); 135 ATF_REQUIRE(!nvlist_empty(nvl)); 136 ATF_REQUIRE(nvlist_exists(nvl, key)); 137 ATF_REQUIRE(nvlist_exists_string(nvl, key)); 138 139 ATF_REQUIRE_EQ(strcmp(cnvlist_get_string(cookie), value), 0); 140 141 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 142 static_cast<const char *>(NULL)); 143 144 nvlist_destroy(nvl); 145 } 146 147 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_nvlist); 148 ATF_TEST_CASE_BODY(cnvlist_get_nvlist) 149 { 150 nvlist_t *nvl, *value; 151 const nvlist_t *result; 152 const char *key, *subkey; 153 void *cookie; 154 int type; 155 156 nvl = nvlist_create(0); 157 ATF_REQUIRE(nvl != NULL); 158 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 159 ATF_REQUIRE(nvlist_empty(nvl)); 160 161 value = nvlist_create(0); 162 ATF_REQUIRE(nvl != NULL); 163 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 164 ATF_REQUIRE(nvlist_empty(nvl)); 165 166 key = "name"; 167 subkey = "subname"; 168 cookie = NULL; 169 170 /* Add null to 'value' nvlist. */ 171 nvlist_add_null(value, subkey); 172 ATF_REQUIRE_EQ(strcmp(subkey, nvlist_next(value, &type, &cookie)), 0); 173 ATF_REQUIRE_EQ(nvlist_error(value), 0); 174 ATF_REQUIRE_EQ(type, NV_TYPE_NULL); 175 ATF_REQUIRE(!nvlist_empty(value)); 176 ATF_REQUIRE(nvlist_exists(value, subkey)); 177 ATF_REQUIRE(nvlist_exists_null(value, subkey)); 178 ATF_REQUIRE_EQ(nvlist_next(value, &type, &cookie), 179 static_cast<const char *>(NULL)); 180 181 /* Add 'value' nvlist. */ 182 cookie = NULL; 183 nvlist_add_nvlist(nvl, key, value); 184 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 185 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 186 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); 187 ATF_REQUIRE(!nvlist_empty(nvl)); 188 ATF_REQUIRE(nvlist_exists(nvl, key)); 189 ATF_REQUIRE(nvlist_exists_nvlist(nvl, key)); 190 191 /* 192 * Assuming nvlist_get_nvlist() is correct check if cnvlist returns 193 * the same pointer. 194 */ 195 result = cnvlist_get_nvlist(cookie); 196 ATF_REQUIRE_EQ(result, nvlist_get_nvlist(nvl, key)); 197 ATF_REQUIRE(result != value); 198 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 199 static_cast<const char *>(NULL)); 200 201 /* Validate data inside nvlist. */ 202 cookie = NULL; 203 ATF_REQUIRE_EQ(strcmp(subkey, nvlist_next(result, &type, &cookie)), 0); 204 ATF_REQUIRE_EQ(nvlist_error(result), 0); 205 ATF_REQUIRE_EQ(type, NV_TYPE_NULL); 206 ATF_REQUIRE(!nvlist_empty(result)); 207 ATF_REQUIRE(nvlist_exists(result, subkey)); 208 ATF_REQUIRE(nvlist_exists_null(result, subkey)); 209 ATF_REQUIRE_EQ(nvlist_next(result, &type, &cookie), 210 static_cast<const char *>(NULL)); 211 212 nvlist_destroy(nvl); 213 nvlist_destroy(value); 214 } 215 216 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_descriptor); 217 ATF_TEST_CASE_BODY(cnvlist_get_descriptor) 218 { 219 nvlist_t *nvl; 220 const char *key; 221 void *cookie; 222 int type; 223 224 nvl = nvlist_create(0); 225 ATF_REQUIRE(nvl != NULL); 226 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 227 ATF_REQUIRE(nvlist_empty(nvl)); 228 229 cookie = NULL; 230 key = "name"; 231 232 nvlist_add_descriptor(nvl, key, STDERR_FILENO); 233 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 234 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 235 ATF_REQUIRE_EQ(type, NV_TYPE_DESCRIPTOR); 236 ATF_REQUIRE(!nvlist_empty(nvl)); 237 ATF_REQUIRE(nvlist_exists(nvl, key)); 238 ATF_REQUIRE(nvlist_exists_descriptor(nvl, key)); 239 240 ATF_REQUIRE_EQ(fd_is_valid(cnvlist_get_descriptor(cookie)), 1); 241 242 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 243 static_cast<const char *>(NULL)); 244 245 nvlist_destroy(nvl); 246 } 247 248 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_binary); 249 ATF_TEST_CASE_BODY(cnvlist_get_binary) 250 { 251 nvlist_t *nvl; 252 const char *key; 253 void *in_binary; 254 const void *out_binary; 255 void *cookie; 256 int type; 257 size_t in_size, out_size; 258 259 nvl = nvlist_create(0); 260 ATF_REQUIRE(nvl != NULL); 261 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 262 ATF_REQUIRE(nvlist_empty(nvl)); 263 264 cookie = NULL; 265 key = "name"; 266 in_size = 13; 267 268 in_binary = malloc(in_size); 269 ATF_REQUIRE(in_binary != NULL); 270 memset(in_binary, 0xa5, in_size); 271 272 nvlist_add_binary(nvl, key, in_binary, in_size); 273 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 274 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 275 ATF_REQUIRE_EQ(type, NV_TYPE_BINARY); 276 ATF_REQUIRE(!nvlist_empty(nvl)); 277 ATF_REQUIRE(nvlist_exists(nvl, key)); 278 ATF_REQUIRE(nvlist_exists_binary(nvl, key)); 279 280 out_binary = cnvlist_get_binary(cookie, &out_size); 281 ATF_REQUIRE_EQ(out_size, in_size); 282 ATF_REQUIRE_EQ(memcmp(in_binary, out_binary, out_size), 0); 283 284 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 285 static_cast<const char *>(NULL)); 286 287 nvlist_destroy(nvl); 288 } 289 290 /* ATF cnvlist_get array tests. */ 291 292 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_bool_array); 293 ATF_TEST_CASE_BODY(cnvlist_get_bool_array) 294 { 295 nvlist_t *nvl; 296 bool in_array[16]; 297 const bool *out_array; 298 const char *key; 299 void *cookie; 300 int type, i; 301 size_t nitems; 302 303 for (i = 0; i < 16; i++) 304 in_array[i] = (i % 2 == 0); 305 306 nvl = nvlist_create(0); 307 ATF_REQUIRE(nvl != NULL); 308 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 309 ATF_REQUIRE(nvlist_empty(nvl)); 310 311 cookie = NULL; 312 key = "name"; 313 314 nvlist_add_bool_array(nvl, key, in_array, 16); 315 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 316 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 317 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL_ARRAY); 318 ATF_REQUIRE(!nvlist_empty(nvl)); 319 ATF_REQUIRE(nvlist_exists(nvl, key)); 320 ATF_REQUIRE(nvlist_exists_bool_array(nvl, key)); 321 322 out_array = cnvlist_get_bool_array(cookie, &nitems); 323 ATF_REQUIRE_EQ(nitems, 16); 324 ATF_REQUIRE(out_array != NULL); 325 for (i = 0; i < 16; i++) 326 ATF_REQUIRE_EQ(out_array[i], in_array[i]); 327 328 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 329 static_cast<const char *>(NULL)); 330 331 nvlist_destroy(nvl); 332 } 333 334 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_number_array); 335 ATF_TEST_CASE_BODY(cnvlist_get_number_array) 336 { 337 nvlist_t *nvl; 338 uint64_t in_array[16]; 339 const uint64_t *out_array; 340 const char *key; 341 void *cookie; 342 int type, i; 343 size_t nitems; 344 345 for (i = 0; i < 16; i++) 346 in_array[i] = i; 347 348 nvl = nvlist_create(0); 349 ATF_REQUIRE(nvl != NULL); 350 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 351 ATF_REQUIRE(nvlist_empty(nvl)); 352 353 cookie = NULL; 354 key = "name"; 355 356 nvlist_add_number_array(nvl, key, in_array, 16); 357 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 358 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 359 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER_ARRAY); 360 ATF_REQUIRE(!nvlist_empty(nvl)); 361 ATF_REQUIRE(nvlist_exists(nvl, key)); 362 ATF_REQUIRE(nvlist_exists_number_array(nvl, key)); 363 364 out_array = cnvlist_get_number_array(cookie, &nitems); 365 ATF_REQUIRE(out_array != NULL); 366 ATF_REQUIRE_EQ(nitems, 16); 367 for (i = 0; i < 16; i++) 368 ATF_REQUIRE_EQ(out_array[i], in_array[i]); 369 370 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 371 static_cast<const char *>(NULL)); 372 373 nvlist_destroy(nvl); 374 } 375 376 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_string_array); 377 ATF_TEST_CASE_BODY(cnvlist_get_string_array) 378 { 379 nvlist_t *nvl; 380 const char *in_array[4] = {"inequality", "sucks", ".", ""}; 381 const char * const *out_array; 382 const char *key; 383 void *cookie; 384 int type, i; 385 size_t nitems; 386 387 nvl = nvlist_create(0); 388 ATF_REQUIRE(nvl != NULL); 389 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 390 ATF_REQUIRE(nvlist_empty(nvl)); 391 392 cookie = NULL; 393 key = "name"; 394 395 nvlist_add_string_array(nvl, key, in_array, 4); 396 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 397 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 398 ATF_REQUIRE_EQ(type, NV_TYPE_STRING_ARRAY); 399 ATF_REQUIRE(!nvlist_empty(nvl)); 400 ATF_REQUIRE(nvlist_exists(nvl, key)); 401 ATF_REQUIRE(nvlist_exists_string_array(nvl, key)); 402 403 out_array = cnvlist_get_string_array(cookie, &nitems); 404 ATF_REQUIRE_EQ(nitems, 4); 405 ATF_REQUIRE(out_array != NULL); 406 for (i = 0; i < 4; i++) { 407 ATF_REQUIRE(out_array[i] != NULL); 408 ATF_REQUIRE_EQ(strcmp(out_array[i], in_array[i]), 0); 409 } 410 411 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 412 static_cast<const char *>(NULL)); 413 414 nvlist_destroy(nvl); 415 } 416 417 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_nvlist_array); 418 ATF_TEST_CASE_BODY(cnvlist_get_nvlist_array) 419 { 420 nvlist_t *nvl; 421 nvlist_t *in_array[6]; 422 const nvlist_t * const *out_array; 423 const nvlist_t * const *out_result; 424 void *cookie; 425 const char *key; 426 const char *subkeys; 427 int type, i; 428 size_t nitems; 429 430 nvl = nvlist_create(0); 431 ATF_REQUIRE(nvl != NULL); 432 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 433 ATF_REQUIRE(nvlist_empty(nvl)); 434 435 subkeys = "123456"; 436 for (i = 0; i < 6; i++) { 437 in_array[i] = nvlist_create(0); 438 ATF_REQUIRE(in_array[i] != NULL); 439 ATF_REQUIRE_EQ(nvlist_error(in_array[i]), 0); 440 ATF_REQUIRE(nvlist_empty(in_array[i])); 441 442 cookie = NULL; 443 444 nvlist_add_null(in_array[i], subkeys+i); 445 ATF_REQUIRE_EQ(strcmp(subkeys+i, nvlist_next(in_array[i], 446 &type, &cookie)),0); 447 ATF_REQUIRE_EQ(nvlist_error(in_array[i]), 0); 448 ATF_REQUIRE_EQ(type, NV_TYPE_NULL); 449 ATF_REQUIRE(!nvlist_empty(in_array[i])); 450 ATF_REQUIRE(nvlist_exists(in_array[i], subkeys+i)); 451 ATF_REQUIRE(nvlist_exists_null(in_array[i], subkeys+i)); 452 ATF_REQUIRE_EQ(nvlist_next(in_array[i], &type, &cookie), 453 static_cast<const char *>(NULL)); 454 } 455 456 cookie = NULL; 457 key = "name"; 458 459 nvlist_add_nvlist_array(nvl, key, in_array, 6); 460 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 461 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 462 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST_ARRAY); 463 ATF_REQUIRE(!nvlist_empty(nvl)); 464 ATF_REQUIRE(nvlist_exists(nvl, key)); 465 ATF_REQUIRE(nvlist_exists_nvlist_array(nvl, key)); 466 467 /* Get nvlist array by cnvlist function. */ 468 out_array = cnvlist_get_nvlist_array(cookie, &nitems); 469 ATF_REQUIRE(out_array != NULL); 470 ATF_REQUIRE_EQ(nitems, 6); 471 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 472 static_cast<const char *>(NULL)); 473 474 /* Get nvlist array by nvlist function. */ 475 out_result = nvlist_get_nvlist_array(nvl, key, &nitems); 476 ATF_REQUIRE(out_result != NULL); 477 ATF_REQUIRE_EQ(nitems, 6); 478 479 /* Validate assuming that nvlist returned a proper pointer */ 480 for (i = 0; i < 6; i++) { 481 ATF_REQUIRE_EQ(out_result[i], out_array[i]); 482 ATF_REQUIRE(out_array[i] != in_array[i]); 483 484 /* Validate data inside nvlist. */ 485 cookie = NULL; 486 ATF_REQUIRE_EQ(strcmp(subkeys+i, nvlist_next(out_array[i], 487 &type, &cookie)), 0); 488 ATF_REQUIRE_EQ(nvlist_error(out_array[i]), 0); 489 ATF_REQUIRE_EQ(type, NV_TYPE_NULL); 490 ATF_REQUIRE(!nvlist_empty(out_array[i])); 491 ATF_REQUIRE(nvlist_exists(out_array[i], subkeys+i)); 492 ATF_REQUIRE(nvlist_exists_null(out_array[i], subkeys+i)); 493 ATF_REQUIRE_EQ(nvlist_next(out_array[i], &type, &cookie), 494 static_cast<const char *>(NULL)); 495 } 496 497 nvlist_destroy(nvl); 498 } 499 500 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_descriptor_array); 501 ATF_TEST_CASE_BODY(cnvlist_get_descriptor_array) 502 { 503 nvlist_t *nvl; 504 size_t count, i, nitems; 505 const int *out_array; 506 int *in_array, type; 507 const char *key; 508 void *cookie; 509 510 nvl = nvlist_create(0); 511 ATF_REQUIRE(nvl != NULL); 512 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 513 ATF_REQUIRE(nvlist_empty(nvl)); 514 515 cookie = NULL; 516 key = "name"; 517 count = 50; 518 519 in_array = static_cast<int *>(malloc(sizeof(*in_array)*count)); 520 ATF_REQUIRE(in_array != NULL); 521 for (i = 0; i < count; i++) { 522 in_array[i] = dup(STDERR_FILENO); 523 ATF_REQUIRE(fd_is_valid(in_array[i])); 524 } 525 526 nvlist_add_descriptor_array(nvl, key, in_array, count); 527 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 528 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 529 ATF_REQUIRE_EQ(type, NV_TYPE_DESCRIPTOR_ARRAY); 530 ATF_REQUIRE(!nvlist_empty(nvl)); 531 ATF_REQUIRE(nvlist_exists(nvl, key)); 532 ATF_REQUIRE(nvlist_exists_descriptor_array(nvl, key)); 533 534 out_array = cnvlist_get_descriptor_array(cookie, &nitems); 535 ATF_REQUIRE_EQ(nitems, count); 536 ATF_REQUIRE(out_array != NULL); 537 for (i = 0; i < count; i++) 538 ATF_REQUIRE_EQ(fd_is_valid(out_array[i]), 1); 539 540 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 541 static_cast<const char *>(NULL)); 542 543 nvlist_destroy(nvl); 544 } 545 546 /* ATF cnvlist_take tests. */ 547 548 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_bool); 549 ATF_TEST_CASE_BODY(cnvlist_take_bool) 550 { 551 nvlist_t *nvl; 552 const char *key; 553 bool value; 554 void *cookie; 555 int type; 556 557 nvl = nvlist_create(0); 558 ATF_REQUIRE(nvl != NULL); 559 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 560 ATF_REQUIRE(nvlist_empty(nvl)); 561 562 cookie = NULL; 563 key = "name"; 564 value = true; 565 566 nvlist_add_bool(nvl, key, value); 567 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 568 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 569 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL); 570 ATF_REQUIRE(!nvlist_empty(nvl)); 571 ATF_REQUIRE(nvlist_exists(nvl, key)); 572 ATF_REQUIRE(nvlist_exists_bool(nvl, key)); 573 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 574 static_cast<const char *>(NULL)); 575 576 cookie = NULL; 577 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 578 ATF_REQUIRE_EQ(cnvlist_take_bool(cookie), value); 579 580 cookie = NULL; 581 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 582 ATF_REQUIRE(nvlist_empty(nvl)); 583 ATF_REQUIRE(!nvlist_exists(nvl, key)); 584 ATF_REQUIRE(!nvlist_exists_bool(nvl, key)); 585 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 586 static_cast<const char *>(NULL)); 587 588 nvlist_destroy(nvl); 589 } 590 591 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_number); 592 ATF_TEST_CASE_BODY(cnvlist_take_number) 593 { 594 nvlist_t *nvl; 595 const char *key; 596 uint64_t value; 597 void *cookie; 598 int type; 599 600 nvl = nvlist_create(0); 601 ATF_REQUIRE(nvl != NULL); 602 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 603 ATF_REQUIRE(nvlist_empty(nvl)); 604 605 cookie = NULL; 606 key = "name"; 607 value = 69; 608 609 nvlist_add_number(nvl, key, value); 610 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 611 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 612 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); 613 ATF_REQUIRE(!nvlist_empty(nvl)); 614 ATF_REQUIRE(nvlist_exists(nvl, key)); 615 ATF_REQUIRE(nvlist_exists_number(nvl, key)); 616 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 617 static_cast<const char *>(NULL)); 618 619 cookie = NULL; 620 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 621 ATF_REQUIRE_EQ(cnvlist_take_number(cookie), value); 622 623 cookie = NULL; 624 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 625 ATF_REQUIRE(nvlist_empty(nvl)); 626 ATF_REQUIRE(!nvlist_exists(nvl, key)); 627 ATF_REQUIRE(!nvlist_exists_number(nvl, key)); 628 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 629 static_cast<const char *>(NULL)); 630 631 nvlist_destroy(nvl); 632 } 633 634 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_string); 635 ATF_TEST_CASE_BODY(cnvlist_take_string) 636 { 637 nvlist_t *nvl; 638 const char *key; 639 const char *value; 640 char *out_string; 641 void *cookie; 642 int type; 643 644 nvl = nvlist_create(0); 645 ATF_REQUIRE(nvl != NULL); 646 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 647 ATF_REQUIRE(nvlist_empty(nvl)); 648 649 cookie = NULL; 650 key = "name"; 651 value = "text"; 652 653 nvlist_add_string(nvl, key, value); 654 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 655 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 656 ATF_REQUIRE_EQ(type, NV_TYPE_STRING); 657 ATF_REQUIRE(!nvlist_empty(nvl)); 658 ATF_REQUIRE(nvlist_exists(nvl, key)); 659 ATF_REQUIRE(nvlist_exists_string(nvl, key)); 660 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 661 static_cast<const char *>(NULL)); 662 663 cookie = NULL; 664 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 665 out_string = cnvlist_take_string(cookie); 666 ATF_REQUIRE(out_string != NULL); 667 ATF_REQUIRE_EQ(strcmp(out_string, value), 0); 668 669 cookie = NULL; 670 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 671 ATF_REQUIRE(nvlist_empty(nvl)); 672 ATF_REQUIRE(!nvlist_exists(nvl, key)); 673 ATF_REQUIRE(!nvlist_exists_string(nvl, key)); 674 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 675 static_cast<const char *>(NULL)); 676 677 free(out_string); 678 nvlist_destroy(nvl); 679 } 680 681 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_nvlist); 682 ATF_TEST_CASE_BODY(cnvlist_take_nvlist) 683 { 684 nvlist_t *nvl, *value, *result; 685 const char *key, *subkey; 686 void *cookie; 687 int type; 688 689 nvl = nvlist_create(0); 690 ATF_REQUIRE(nvl != NULL); 691 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 692 ATF_REQUIRE(nvlist_empty(nvl)); 693 694 value = nvlist_create(0); 695 ATF_REQUIRE(value != NULL); 696 ATF_REQUIRE_EQ(nvlist_error(value), 0); 697 ATF_REQUIRE(nvlist_empty(value)); 698 699 key = "name"; 700 subkey = "subname"; 701 cookie = NULL; 702 703 /* Add null to 'value' nvlist. */ 704 nvlist_add_null(value, subkey); 705 ATF_REQUIRE_EQ(strcmp(subkey, nvlist_next(value, &type, &cookie)), 0); 706 ATF_REQUIRE_EQ(nvlist_error(value), 0); 707 ATF_REQUIRE_EQ(type, NV_TYPE_NULL); 708 ATF_REQUIRE(!nvlist_empty(value)); 709 ATF_REQUIRE(nvlist_exists(value, subkey)); 710 ATF_REQUIRE(nvlist_exists_null(value, subkey)); 711 ATF_REQUIRE_EQ(nvlist_next(value, &type, &cookie), 712 static_cast<const char *>(NULL)); 713 714 /* Add 'value' nvlist. */ 715 cookie = NULL; 716 nvlist_move_nvlist(nvl, key, value); 717 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 718 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 719 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); 720 ATF_REQUIRE(!nvlist_empty(nvl)); 721 ATF_REQUIRE(nvlist_exists(nvl, key)); 722 ATF_REQUIRE(nvlist_exists_nvlist(nvl, key)); 723 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 724 static_cast<const char *>(NULL)); 725 726 cookie = NULL; 727 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 728 result = cnvlist_take_nvlist(cookie); 729 ATF_REQUIRE(!nvlist_exists_nvlist(nvl, key)); 730 ATF_REQUIRE(result == value); 731 732 /* Validate data inside nvlist. */ 733 cookie = NULL; 734 ATF_REQUIRE_EQ(strcmp(subkey, nvlist_next(result, &type, &cookie)), 0); 735 ATF_REQUIRE_EQ(nvlist_error(value), 0); 736 ATF_REQUIRE_EQ(type, NV_TYPE_NULL); 737 ATF_REQUIRE(!nvlist_empty(value)); 738 ATF_REQUIRE(nvlist_exists(value, subkey)); 739 ATF_REQUIRE(nvlist_exists_null(value, subkey)); 740 ATF_REQUIRE_EQ(nvlist_next(value, &type, &cookie), 741 static_cast<const char *>(NULL)); 742 743 cookie = NULL; 744 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 745 static_cast<const char *>(NULL)); 746 747 nvlist_destroy(nvl); 748 nvlist_destroy(value); 749 } 750 751 /* ATF cnvlist_take array tests */ 752 753 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_bool_array); 754 ATF_TEST_CASE_BODY(cnvlist_take_bool_array) 755 { 756 nvlist_t *nvl; 757 bool in_array[16]; 758 const bool *out_array; 759 const char *key; 760 void *cookie; 761 int type, i; 762 size_t nitems; 763 764 for (i = 0; i < 16; i++) 765 in_array[i] = (i % 2 == 0); 766 767 nvl = nvlist_create(0); 768 ATF_REQUIRE(nvl != NULL); 769 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 770 ATF_REQUIRE(nvlist_empty(nvl)); 771 772 cookie = NULL; 773 key = "name"; 774 775 nvlist_add_bool_array(nvl, key, in_array, 16); 776 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 777 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 778 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL_ARRAY); 779 ATF_REQUIRE(!nvlist_empty(nvl)); 780 ATF_REQUIRE(nvlist_exists(nvl, key)); 781 ATF_REQUIRE(nvlist_exists_bool_array(nvl, key)); 782 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 783 static_cast<const char *>(NULL)); 784 785 cookie = NULL; 786 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 787 out_array = cnvlist_take_bool_array(cookie, &nitems); 788 ATF_REQUIRE_EQ(nitems, 16); 789 ATF_REQUIRE(out_array != NULL); 790 for (i = 0; i < 16; i++) 791 ATF_REQUIRE_EQ(out_array[i], in_array[i]); 792 793 cookie = NULL; 794 ATF_REQUIRE(!nvlist_exists_bool_array(nvl, key)); 795 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 796 ATF_REQUIRE(nvlist_empty(nvl)); 797 ATF_REQUIRE(!nvlist_exists(nvl, key)); 798 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 799 static_cast<const char *>(NULL)); 800 801 802 nvlist_destroy(nvl); 803 } 804 805 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_number_array); 806 ATF_TEST_CASE_BODY(cnvlist_take_number_array) 807 { 808 nvlist_t *nvl; 809 uint64_t in_array[16]; 810 const uint64_t *out_array; 811 const char *key; 812 void *cookie; 813 int type, i; 814 size_t nitems; 815 816 for (i = 0; i < 16; i++) 817 in_array[i] = i; 818 819 nvl = nvlist_create(0); 820 ATF_REQUIRE(nvl != NULL); 821 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 822 ATF_REQUIRE(nvlist_empty(nvl)); 823 824 cookie = NULL; 825 key = "name"; 826 827 nvlist_add_number_array(nvl, key, in_array, 16); 828 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 829 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 830 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER_ARRAY); 831 ATF_REQUIRE(!nvlist_empty(nvl)); 832 ATF_REQUIRE(nvlist_exists(nvl, key)); 833 ATF_REQUIRE(nvlist_exists_number_array(nvl, key)); 834 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 835 static_cast<const char *>(NULL)); 836 837 cookie = NULL; 838 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 839 out_array = cnvlist_take_number_array(cookie, &nitems); 840 841 ATF_REQUIRE(out_array != NULL); 842 ATF_REQUIRE_EQ(nitems, 16); 843 for (i = 0; i < 16; i++) 844 ATF_REQUIRE_EQ(out_array[i], in_array[i]); 845 846 cookie = NULL; 847 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 848 ATF_REQUIRE(nvlist_empty(nvl)); 849 ATF_REQUIRE(!nvlist_exists(nvl, key)); 850 ATF_REQUIRE(!nvlist_exists_number_array(nvl, key)); 851 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 852 static_cast<const char *>(NULL)); 853 854 nvlist_destroy(nvl); 855 } 856 857 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_string_array); 858 ATF_TEST_CASE_BODY(cnvlist_take_string_array) 859 { 860 nvlist_t *nvl; 861 const char *in_array[4] = {"inequality", "sks", ".", ""}; 862 char **out_array; 863 const char *key; 864 void *cookie; 865 int type, i; 866 size_t nitems; 867 868 nvl = nvlist_create(0); 869 ATF_REQUIRE(nvl != NULL); 870 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 871 ATF_REQUIRE(nvlist_empty(nvl)); 872 873 cookie = NULL; 874 key = "name"; 875 876 nvlist_add_string_array(nvl, key, in_array, 4); 877 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 878 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 879 ATF_REQUIRE_EQ(type, NV_TYPE_STRING_ARRAY); 880 ATF_REQUIRE(!nvlist_empty(nvl)); 881 ATF_REQUIRE(nvlist_exists(nvl, key)); 882 ATF_REQUIRE(nvlist_exists_string_array(nvl, key)); 883 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 884 static_cast<const char *>(NULL)); 885 886 cookie = NULL; 887 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 888 out_array = cnvlist_take_string_array(cookie, &nitems); 889 ATF_REQUIRE_EQ(nitems, 4); 890 for (i = 0; i < 4; i++) { 891 ATF_REQUIRE(out_array[i] != NULL); 892 ATF_REQUIRE_EQ(strcmp(out_array[i], in_array[i]), 0); 893 } 894 ATF_REQUIRE(nvlist_empty(nvl)); 895 896 cookie = NULL; 897 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 898 ATF_REQUIRE(nvlist_empty(nvl)); 899 ATF_REQUIRE(!nvlist_exists(nvl, key)); 900 ATF_REQUIRE(!nvlist_exists_number_array(nvl, key)); 901 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 902 static_cast<const char *>(NULL)); 903 904 free(out_array); 905 nvlist_destroy(nvl); 906 } 907 908 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_nvlist_array); 909 ATF_TEST_CASE_BODY(cnvlist_take_nvlist_array) 910 { 911 nvlist_t *testnvl[8]; 912 nvlist_t **result; 913 nvlist_t *nvl; 914 void *cookie; 915 size_t num_items; 916 unsigned int i; 917 int type; 918 const char *somestr[8] = { "a", "b", "c", "d", "e", "f", "g", "h" }; 919 const char *key; 920 921 for (i = 0; i < 8; i++) { 922 testnvl[i] = nvlist_create(0); 923 ATF_REQUIRE(testnvl[i] != NULL); 924 ATF_REQUIRE_EQ(nvlist_error(testnvl[i]), 0); 925 ATF_REQUIRE(nvlist_empty(testnvl[i])); 926 nvlist_add_string(testnvl[i], "nvl/string", somestr[i]); 927 928 cookie = NULL; 929 ATF_REQUIRE_EQ(strcmp("nvl/string", nvlist_next(testnvl[i], 930 &type, &cookie)), 0); 931 ATF_REQUIRE_EQ(nvlist_error(testnvl[i]), 0); 932 ATF_REQUIRE_EQ(type, NV_TYPE_STRING); 933 ATF_REQUIRE(!nvlist_empty(testnvl[i])); 934 ATF_REQUIRE(nvlist_exists(testnvl[i], "nvl/string")); 935 ATF_REQUIRE(nvlist_exists_string(testnvl[i], "nvl/string")); 936 ATF_REQUIRE_EQ(nvlist_next(testnvl[i], &type, &cookie), 937 static_cast<const char *>(NULL)); 938 } 939 940 nvl = nvlist_create(0); 941 ATF_REQUIRE(nvl != NULL); 942 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 943 ATF_REQUIRE(nvlist_empty(nvl)); 944 945 key = "nvl/nvlist"; 946 cookie = NULL; 947 948 nvlist_add_nvlist_array(nvl, key, (const nvlist_t * const *)testnvl, 8); 949 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 950 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 951 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST_ARRAY); 952 ATF_REQUIRE(!nvlist_empty(nvl)); 953 ATF_REQUIRE(nvlist_exists(nvl, key)); 954 ATF_REQUIRE(nvlist_exists_nvlist_array(nvl, key)); 955 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 956 static_cast<const char *>(NULL)); 957 958 cookie = NULL; 959 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 960 result = cnvlist_take_nvlist_array(cookie, &num_items); 961 962 ATF_REQUIRE(result != NULL); 963 ATF_REQUIRE_EQ(num_items, 8); 964 for (i = 0; i < num_items; i++) { 965 ATF_REQUIRE_EQ(nvlist_error(result[i]), 0); 966 ATF_REQUIRE(nvlist_get_array_next(result[i]) == NULL); 967 } 968 969 ATF_REQUIRE(!nvlist_exists_string_array(nvl, key)); 970 ATF_REQUIRE(nvlist_empty(nvl)); 971 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 972 973 cookie = NULL; 974 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 975 ATF_REQUIRE(nvlist_empty(nvl)); 976 ATF_REQUIRE(!nvlist_exists(nvl, key)); 977 ATF_REQUIRE(!nvlist_exists_nvlist_array(nvl, key)); 978 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 979 static_cast<const char *>(NULL)); 980 981 for (i = 0; i < 8; i++) { 982 nvlist_destroy(result[i]); 983 nvlist_destroy(testnvl[i]); 984 } 985 986 free(result); 987 nvlist_destroy(nvl); 988 } 989 990 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_binary); 991 ATF_TEST_CASE_BODY(cnvlist_take_binary) 992 { 993 nvlist_t *nvl; 994 const char *key; 995 void *in_binary; 996 const void *out_binary; 997 void *cookie; 998 int type; 999 size_t in_size, out_size; 1000 1001 nvl = nvlist_create(0); 1002 ATF_REQUIRE(nvl != NULL); 1003 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1004 ATF_REQUIRE(nvlist_empty(nvl)); 1005 1006 cookie = NULL; 1007 key = "name"; 1008 in_size = 13; 1009 in_binary = malloc(in_size); 1010 ATF_REQUIRE(in_binary != NULL); 1011 memset(in_binary, 0xa5, in_size); 1012 1013 nvlist_add_binary(nvl, key, in_binary, in_size); 1014 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1015 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1016 ATF_REQUIRE_EQ(type, NV_TYPE_BINARY); 1017 ATF_REQUIRE(!nvlist_empty(nvl)); 1018 ATF_REQUIRE(nvlist_exists(nvl, key)); 1019 ATF_REQUIRE(nvlist_exists_binary(nvl, key)); 1020 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1021 static_cast<const char *>(NULL)); 1022 1023 cookie = NULL; 1024 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1025 out_binary = cnvlist_take_binary(cookie, &out_size); 1026 ATF_REQUIRE_EQ(out_size, in_size); 1027 ATF_REQUIRE_EQ(memcmp(in_binary, out_binary, out_size), 0); 1028 1029 cookie = NULL; 1030 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1031 ATF_REQUIRE(nvlist_empty(nvl)); 1032 ATF_REQUIRE(!nvlist_exists(nvl, key)); 1033 ATF_REQUIRE(!nvlist_exists_binary(nvl, key)); 1034 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1035 static_cast<const char *>(NULL)); 1036 1037 nvlist_destroy(nvl); 1038 } 1039 1040 /* ATF cnvlist_free tests. */ 1041 1042 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_bool); 1043 ATF_TEST_CASE_BODY(cnvlist_free_bool) 1044 { 1045 nvlist_t *nvl; 1046 const char *key; 1047 bool value; 1048 void *cookie; 1049 int type; 1050 1051 nvl = nvlist_create(0); 1052 ATF_REQUIRE(nvl != NULL); 1053 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1054 ATF_REQUIRE(nvlist_empty(nvl)); 1055 1056 cookie = NULL; 1057 key = "name"; 1058 value = true; 1059 1060 nvlist_add_bool(nvl, key, value); 1061 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1062 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1063 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL); 1064 ATF_REQUIRE(!nvlist_empty(nvl)); 1065 ATF_REQUIRE(nvlist_exists(nvl, key)); 1066 ATF_REQUIRE(nvlist_exists_bool(nvl, key)); 1067 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1068 static_cast<const char *>(NULL)); 1069 1070 cookie = NULL; 1071 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1072 cnvlist_free_bool(cookie); 1073 1074 cookie = NULL; 1075 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1076 ATF_REQUIRE(nvlist_empty(nvl)); 1077 ATF_REQUIRE(!nvlist_exists(nvl, key)); 1078 ATF_REQUIRE(!nvlist_exists_bool(nvl, key)); 1079 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1080 static_cast<const char *>(NULL)); 1081 1082 nvlist_destroy(nvl); 1083 } 1084 1085 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_number); 1086 ATF_TEST_CASE_BODY(cnvlist_free_number) 1087 { 1088 nvlist_t *nvl; 1089 const char *key; 1090 uint64_t value; 1091 void *cookie; 1092 int type; 1093 1094 nvl = nvlist_create(0); 1095 ATF_REQUIRE(nvl != NULL); 1096 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1097 ATF_REQUIRE(nvlist_empty(nvl)); 1098 1099 cookie = NULL; 1100 key = "name"; 1101 value = 69; 1102 1103 nvlist_add_number(nvl, key, value); 1104 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1105 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1106 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); 1107 ATF_REQUIRE(!nvlist_empty(nvl)); 1108 ATF_REQUIRE(nvlist_exists(nvl, key)); 1109 ATF_REQUIRE(nvlist_exists_number(nvl, key)); 1110 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1111 static_cast<const char *>(NULL)); 1112 1113 cookie = NULL; 1114 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1115 cnvlist_free_number(cookie); 1116 1117 cookie = NULL; 1118 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1119 ATF_REQUIRE(nvlist_empty(nvl)); 1120 ATF_REQUIRE(!nvlist_exists(nvl, key)); 1121 ATF_REQUIRE(!nvlist_exists_number(nvl, key)); 1122 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1123 static_cast<const char *>(NULL)); 1124 1125 nvlist_destroy(nvl); 1126 } 1127 1128 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_string); 1129 ATF_TEST_CASE_BODY(cnvlist_free_string) 1130 { 1131 nvlist_t *nvl; 1132 const char *key; 1133 const char *value; 1134 void *cookie; 1135 int type; 1136 1137 nvl = nvlist_create(0); 1138 ATF_REQUIRE(nvl != NULL); 1139 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1140 ATF_REQUIRE(nvlist_empty(nvl)); 1141 1142 cookie = NULL; 1143 key = "name"; 1144 value = "text"; 1145 1146 nvlist_add_string(nvl, key, value); 1147 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1148 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1149 ATF_REQUIRE_EQ(type, NV_TYPE_STRING); 1150 ATF_REQUIRE(!nvlist_empty(nvl)); 1151 ATF_REQUIRE(nvlist_exists(nvl, key)); 1152 ATF_REQUIRE(nvlist_exists_string(nvl, key)); 1153 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1154 static_cast<const char *>(NULL)); 1155 1156 cookie = NULL; 1157 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1158 cnvlist_free_string(cookie); 1159 1160 cookie = NULL; 1161 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1162 ATF_REQUIRE(nvlist_empty(nvl)); 1163 ATF_REQUIRE(!nvlist_exists(nvl, key)); 1164 ATF_REQUIRE(!nvlist_exists_string(nvl, key)); 1165 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1166 static_cast<const char *>(NULL)); 1167 1168 nvlist_destroy(nvl); 1169 } 1170 1171 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_nvlist); 1172 ATF_TEST_CASE_BODY(cnvlist_free_nvlist) 1173 { 1174 nvlist_t *nvl, *value; 1175 const char *key, *subkey; 1176 void *cookie; 1177 int type; 1178 1179 nvl = nvlist_create(0); 1180 ATF_REQUIRE(nvl != NULL); 1181 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1182 ATF_REQUIRE(nvlist_empty(nvl)); 1183 1184 value = nvlist_create(0); 1185 ATF_REQUIRE(nvl != NULL); 1186 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1187 ATF_REQUIRE(nvlist_empty(nvl)); 1188 1189 key = "name"; 1190 subkey = "subname"; 1191 cookie = NULL; 1192 1193 /* Add null to 'value' nvlist. */ 1194 nvlist_add_null(value, subkey); 1195 ATF_REQUIRE_EQ(strcmp(subkey, nvlist_next(value, &type, &cookie)), 0); 1196 ATF_REQUIRE_EQ(nvlist_error(value), 0); 1197 ATF_REQUIRE_EQ(type, NV_TYPE_NULL); 1198 ATF_REQUIRE(!nvlist_empty(value)); 1199 ATF_REQUIRE(nvlist_exists(value, subkey)); 1200 ATF_REQUIRE(nvlist_exists_null(value, subkey)); 1201 ATF_REQUIRE_EQ(nvlist_next(value, &type, &cookie), 1202 static_cast<const char *>(NULL)); 1203 1204 /* Add 'value' nvlist. */ 1205 cookie = NULL; 1206 nvlist_move_nvlist(nvl, key, value); 1207 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1208 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1209 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); 1210 ATF_REQUIRE(!nvlist_empty(nvl)); 1211 ATF_REQUIRE(nvlist_exists(nvl, key)); 1212 ATF_REQUIRE(nvlist_exists_nvlist(nvl, key)); 1213 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1214 static_cast<const char *>(NULL)); 1215 1216 cookie = NULL; 1217 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1218 cnvlist_free_nvlist(cookie); 1219 1220 cookie = NULL; 1221 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1222 ATF_REQUIRE(nvlist_empty(nvl)); 1223 ATF_REQUIRE(!nvlist_exists(nvl, key)); 1224 ATF_REQUIRE(!nvlist_exists_nvlist(nvl, key)); 1225 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1226 static_cast<const char *>(NULL)); 1227 1228 nvlist_destroy(nvl); 1229 } 1230 1231 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_binary); 1232 ATF_TEST_CASE_BODY(cnvlist_free_binary) 1233 { 1234 nvlist_t *nvl; 1235 const char *key; 1236 void *in_binary; 1237 void *cookie; 1238 int type; 1239 size_t in_size; 1240 1241 nvl = nvlist_create(0); 1242 ATF_REQUIRE(nvl != NULL); 1243 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1244 ATF_REQUIRE(nvlist_empty(nvl)); 1245 1246 cookie = NULL; 1247 key = "name"; 1248 in_size = 13; 1249 in_binary = malloc(in_size); 1250 ATF_REQUIRE(in_binary != NULL); 1251 memset(in_binary, 0xa5, in_size); 1252 1253 nvlist_add_binary(nvl, key, in_binary, in_size); 1254 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1255 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1256 ATF_REQUIRE_EQ(type, NV_TYPE_BINARY); 1257 ATF_REQUIRE(!nvlist_empty(nvl)); 1258 ATF_REQUIRE(nvlist_exists(nvl, key)); 1259 ATF_REQUIRE(nvlist_exists_binary(nvl, key)); 1260 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1261 static_cast<const char *>(NULL)); 1262 1263 cookie = NULL; 1264 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1265 cnvlist_free_binary(cookie); 1266 1267 cookie = NULL; 1268 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1269 ATF_REQUIRE(nvlist_empty(nvl)); 1270 ATF_REQUIRE(!nvlist_exists(nvl, key)); 1271 ATF_REQUIRE(!nvlist_exists_nvlist(nvl, key)); 1272 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1273 static_cast<const char *>(NULL)); 1274 1275 nvlist_destroy(nvl); 1276 } 1277 1278 /* ATF cnvlist_free array tests. */ 1279 1280 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_bool_array); 1281 ATF_TEST_CASE_BODY(cnvlist_free_bool_array) 1282 { 1283 nvlist_t *nvl; 1284 bool in_array[16]; 1285 const char *key; 1286 void *cookie; 1287 int type, i; 1288 1289 for (i = 0; i < 16; i++) 1290 in_array[i] = (i % 2 == 0); 1291 1292 nvl = nvlist_create(0); 1293 ATF_REQUIRE(nvl != NULL); 1294 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1295 ATF_REQUIRE(nvlist_empty(nvl)); 1296 1297 cookie = NULL; 1298 key = "name"; 1299 1300 nvlist_add_bool_array(nvl, key, in_array, 16); 1301 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1302 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1303 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL_ARRAY); 1304 ATF_REQUIRE(!nvlist_empty(nvl)); 1305 ATF_REQUIRE(nvlist_exists(nvl, key)); 1306 ATF_REQUIRE(nvlist_exists_bool_array(nvl, key)); 1307 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1308 static_cast<const char *>(NULL)); 1309 1310 cookie = NULL; 1311 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1312 cnvlist_free_bool_array(cookie); 1313 1314 cookie = NULL; 1315 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1316 ATF_REQUIRE(nvlist_empty(nvl)); 1317 ATF_REQUIRE(!nvlist_exists(nvl, key)); 1318 ATF_REQUIRE(!nvlist_exists_bool(nvl, key)); 1319 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1320 static_cast<const char *>(NULL)); 1321 1322 nvlist_destroy(nvl); 1323 } 1324 1325 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_number_array); 1326 ATF_TEST_CASE_BODY(cnvlist_free_number_array) 1327 { 1328 nvlist_t *nvl; 1329 uint64_t in_array[16]; 1330 const char *key; 1331 void *cookie; 1332 int type, i; 1333 1334 for (i = 0; i < 16; i++) 1335 in_array[i] = i; 1336 1337 nvl = nvlist_create(0); 1338 ATF_REQUIRE(nvl != NULL); 1339 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1340 ATF_REQUIRE(nvlist_empty(nvl)); 1341 1342 cookie = NULL; 1343 key = "name"; 1344 1345 nvlist_add_number_array(nvl, key, in_array, 16); 1346 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1347 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1348 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER_ARRAY); 1349 ATF_REQUIRE(!nvlist_empty(nvl)); 1350 ATF_REQUIRE(nvlist_exists(nvl, key)); 1351 ATF_REQUIRE(nvlist_exists_number_array(nvl, key)); 1352 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1353 static_cast<const char *>(NULL)); 1354 1355 cookie = NULL; 1356 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1357 cnvlist_free_number_array(cookie); 1358 1359 cookie = NULL; 1360 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1361 ATF_REQUIRE(nvlist_empty(nvl)); 1362 ATF_REQUIRE(!nvlist_exists(nvl, key)); 1363 ATF_REQUIRE(!nvlist_exists_number_array(nvl, key)); 1364 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1365 static_cast<const char *>(NULL)); 1366 1367 nvlist_destroy(nvl); 1368 } 1369 1370 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_string_array); 1371 ATF_TEST_CASE_BODY(cnvlist_free_string_array) 1372 { 1373 nvlist_t *nvl; 1374 const char *in_array[4] = {"inequality", "sucks", ".", ""}; 1375 const char *key; 1376 void *cookie; 1377 int type; 1378 1379 nvl = nvlist_create(0); 1380 ATF_REQUIRE(nvl != NULL); 1381 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1382 ATF_REQUIRE(nvlist_empty(nvl)); 1383 1384 cookie = NULL; 1385 key = "name"; 1386 1387 nvlist_add_string_array(nvl, key, in_array, 4); 1388 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1389 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1390 ATF_REQUIRE_EQ(type, NV_TYPE_STRING_ARRAY); 1391 ATF_REQUIRE(!nvlist_empty(nvl)); 1392 ATF_REQUIRE(nvlist_exists(nvl, key)); 1393 ATF_REQUIRE(nvlist_exists_string_array(nvl, key)); 1394 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1395 static_cast<const char *>(NULL)); 1396 1397 cookie = NULL; 1398 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1399 cnvlist_free_string_array(cookie); 1400 1401 cookie = NULL; 1402 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1403 ATF_REQUIRE(nvlist_empty(nvl)); 1404 ATF_REQUIRE(!nvlist_exists(nvl, key)); 1405 ATF_REQUIRE(!nvlist_exists_string_array(nvl, key)); 1406 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1407 static_cast<const char *>(NULL)); 1408 1409 nvlist_destroy(nvl); 1410 } 1411 1412 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_nvlist_array); 1413 ATF_TEST_CASE_BODY(cnvlist_free_nvlist_array) 1414 { 1415 nvlist_t *testnvl[8]; 1416 nvlist_t *nvl; 1417 void *cookie; 1418 unsigned int i; 1419 int type; 1420 const char *somestr[8] = { "a", "b", "c", "d", "e", "f", "g", "h" }; 1421 const char *key; 1422 1423 for (i = 0; i < 8; i++) { 1424 testnvl[i] = nvlist_create(0); 1425 ATF_REQUIRE(testnvl[i] != NULL); 1426 ATF_REQUIRE_EQ(nvlist_error(testnvl[i]), 0); 1427 ATF_REQUIRE(nvlist_empty(testnvl[i])); 1428 nvlist_add_string(testnvl[i], "nvl/string", somestr[i]); 1429 1430 cookie = NULL; 1431 ATF_REQUIRE_EQ(strcmp("nvl/string", nvlist_next(testnvl[i], 1432 &type, &cookie)), 0); 1433 ATF_REQUIRE_EQ(nvlist_error(testnvl[i]), 0); 1434 ATF_REQUIRE_EQ(type, NV_TYPE_STRING); 1435 ATF_REQUIRE(!nvlist_empty(testnvl[i])); 1436 ATF_REQUIRE(nvlist_exists(testnvl[i], "nvl/string")); 1437 ATF_REQUIRE(nvlist_exists_string(testnvl[i], "nvl/string")); 1438 ATF_REQUIRE_EQ(nvlist_next(testnvl[i], &type, &cookie), 1439 static_cast<const char *>(NULL)); 1440 } 1441 1442 nvl = nvlist_create(0); 1443 ATF_REQUIRE(nvl != NULL); 1444 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1445 ATF_REQUIRE(nvlist_empty(nvl)); 1446 1447 key = "nvl/nvlist"; 1448 cookie = NULL; 1449 1450 nvlist_add_nvlist_array(nvl, key, (const nvlist_t * const *)testnvl, 8); 1451 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1452 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1453 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST_ARRAY); 1454 ATF_REQUIRE(!nvlist_empty(nvl)); 1455 ATF_REQUIRE(nvlist_exists(nvl, key)); 1456 ATF_REQUIRE(nvlist_exists_nvlist_array(nvl, key)); 1457 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1458 static_cast<const char *>(NULL)); 1459 1460 cookie = NULL; 1461 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0); 1462 cnvlist_free_nvlist_array(cookie); 1463 1464 cookie = NULL; 1465 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 1466 ATF_REQUIRE(nvlist_empty(nvl)); 1467 ATF_REQUIRE(!nvlist_exists(nvl, key)); 1468 ATF_REQUIRE(!nvlist_exists_nvlist_array(nvl, key)); 1469 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie), 1470 static_cast<const char *>(NULL)); 1471 1472 for (i = 0; i < 8; i++) 1473 nvlist_destroy(testnvl[i]); 1474 nvlist_destroy(nvl); 1475 } 1476 1477 ATF_INIT_TEST_CASES(tp) 1478 { 1479 ATF_ADD_TEST_CASE(tp, cnvlist_get_bool); 1480 ATF_ADD_TEST_CASE(tp, cnvlist_get_bool_array); 1481 ATF_ADD_TEST_CASE(tp, cnvlist_get_number); 1482 ATF_ADD_TEST_CASE(tp, cnvlist_get_string); 1483 ATF_ADD_TEST_CASE(tp, cnvlist_get_nvlist); 1484 ATF_ADD_TEST_CASE(tp, cnvlist_get_descriptor); 1485 ATF_ADD_TEST_CASE(tp, cnvlist_get_binary); 1486 ATF_ADD_TEST_CASE(tp, cnvlist_get_number_array); 1487 ATF_ADD_TEST_CASE(tp, cnvlist_get_string_array); 1488 ATF_ADD_TEST_CASE(tp, cnvlist_get_nvlist_array); 1489 ATF_ADD_TEST_CASE(tp, cnvlist_get_descriptor_array); 1490 ATF_ADD_TEST_CASE(tp, cnvlist_take_bool); 1491 ATF_ADD_TEST_CASE(tp, cnvlist_take_number); 1492 ATF_ADD_TEST_CASE(tp, cnvlist_take_string); 1493 ATF_ADD_TEST_CASE(tp, cnvlist_take_nvlist); 1494 ATF_ADD_TEST_CASE(tp, cnvlist_take_binary); 1495 ATF_ADD_TEST_CASE(tp, cnvlist_take_bool_array); 1496 ATF_ADD_TEST_CASE(tp, cnvlist_take_number_array); 1497 ATF_ADD_TEST_CASE(tp, cnvlist_take_string_array); 1498 ATF_ADD_TEST_CASE(tp, cnvlist_take_nvlist_array); 1499 ATF_ADD_TEST_CASE(tp, cnvlist_free_bool); 1500 ATF_ADD_TEST_CASE(tp, cnvlist_free_number); 1501 ATF_ADD_TEST_CASE(tp, cnvlist_free_string); 1502 ATF_ADD_TEST_CASE(tp, cnvlist_free_nvlist); 1503 ATF_ADD_TEST_CASE(tp, cnvlist_free_binary); 1504 ATF_ADD_TEST_CASE(tp, cnvlist_free_bool_array); 1505 ATF_ADD_TEST_CASE(tp, cnvlist_free_number_array); 1506 ATF_ADD_TEST_CASE(tp, cnvlist_free_string_array); 1507 ATF_ADD_TEST_CASE(tp, cnvlist_free_nvlist_array); 1508 } 1509