1 /*- 2 * Copyright (c) 2014-2015 Sandvine Inc. All rights reserved. 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 AUTHOR 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 AUTHOR 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 27 #include <sys/cdefs.h> 28 #include <sys/nv.h> 29 30 #include <atf-c++.hpp> 31 32 #include <errno.h> 33 #include <limits> 34 #include <set> 35 #include <sstream> 36 #include <string> 37 38 /* 39 * Test that a newly created nvlist has no errors, and is empty. 40 */ 41 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty); 42 ATF_TEST_CASE_BODY(nvlist_create__is_empty) 43 { 44 nvlist_t *nvl; 45 int type; 46 void *it; 47 48 nvl = nvlist_create(0); 49 50 ATF_REQUIRE(nvl != NULL); 51 52 ATF_REQUIRE_EQ(nvlist_error(nvl), 0); 53 ATF_REQUIRE(nvlist_empty(nvl)); 54 55 it = NULL; 56 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), static_cast<const char *>(NULL)); 57 58 nvlist_destroy(nvl); 59 } 60 61 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert); 62 ATF_TEST_CASE_BODY(nvlist_add_null__single_insert) 63 { 64 nvlist_t *nvl; 65 void *it; 66 const char *key; 67 int type; 68 69 key = "key"; 70 nvl = nvlist_create(0); 71 72 ATF_REQUIRE(nvl != NULL); 73 ATF_REQUIRE(!nvlist_exists(nvl, key)); 74 75 nvlist_add_null(nvl, key); 76 77 ATF_REQUIRE(!nvlist_empty(nvl)); 78 ATF_REQUIRE(nvlist_exists(nvl, key)); 79 ATF_REQUIRE(nvlist_exists_null(nvl, key)); 80 ATF_REQUIRE(nvlist_exists_null(nvl, "key")); 81 82 /* Iterate over the nvlist; ensure that it has only our one key. */ 83 it = NULL; 84 ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); 85 ATF_REQUIRE_EQ(type, NV_TYPE_NULL); 86 ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL)); 87 88 nvlist_destroy(nvl); 89 } 90 91 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert); 92 ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert) 93 { 94 nvlist_t *nvl; 95 void *it; 96 const char *key; 97 int type; 98 99 key = "name"; 100 nvl = nvlist_create(0); 101 102 ATF_REQUIRE(nvl != NULL); 103 ATF_REQUIRE(!nvlist_exists(nvl, key)); 104 105 nvlist_add_bool(nvl, key, true); 106 107 ATF_REQUIRE(!nvlist_empty(nvl)); 108 ATF_REQUIRE(nvlist_exists(nvl, key)); 109 ATF_REQUIRE(nvlist_exists(nvl, "name")); 110 ATF_REQUIRE(nvlist_exists_bool(nvl, key)); 111 ATF_REQUIRE(nvlist_exists_bool(nvl, "name")); 112 ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true); 113 114 /* Iterate over the nvlist; ensure that it has only our one key. */ 115 it = NULL; 116 ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); 117 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL); 118 ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL)); 119 120 nvlist_destroy(nvl); 121 } 122 123 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert); 124 ATF_TEST_CASE_BODY(nvlist_add_number__single_insert) 125 { 126 nvlist_t *nvl; 127 void *it; 128 const char *key; 129 uint64_t value; 130 int type; 131 132 key = "foo123"; 133 value = 71965; 134 nvl = nvlist_create(0); 135 136 ATF_REQUIRE(nvl != NULL); 137 ATF_REQUIRE(!nvlist_exists(nvl, key)); 138 139 nvlist_add_number(nvl, key, value); 140 141 ATF_REQUIRE(!nvlist_empty(nvl)); 142 ATF_REQUIRE(nvlist_exists(nvl, key)); 143 ATF_REQUIRE(nvlist_exists(nvl, "foo123")); 144 ATF_REQUIRE(nvlist_exists_number(nvl, key)); 145 ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value); 146 147 /* Iterate over the nvlist; ensure that it has only our one key. */ 148 it = NULL; 149 ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); 150 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); 151 ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL)); 152 153 nvlist_destroy(nvl); 154 } 155 156 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert); 157 ATF_TEST_CASE_BODY(nvlist_add_string__single_insert) 158 { 159 nvlist_t *nvl; 160 void *it; 161 const char *key; 162 const char *value; 163 int type; 164 165 key = "test"; 166 value = "fgjdkgjdk"; 167 nvl = nvlist_create(0); 168 169 ATF_REQUIRE(nvl != NULL); 170 ATF_REQUIRE(!nvlist_exists(nvl, key)); 171 172 nvlist_add_string(nvl, key, value); 173 174 ATF_REQUIRE(!nvlist_empty(nvl)); 175 ATF_REQUIRE(nvlist_exists(nvl, key)); 176 ATF_REQUIRE(nvlist_exists(nvl, "test")); 177 ATF_REQUIRE(nvlist_exists_string(nvl, key)); 178 ATF_REQUIRE(nvlist_exists_string(nvl, "test")); 179 ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0); 180 181 /* nvlist_add_* is required to clone the value, so check for that. */ 182 ATF_REQUIRE(nvlist_get_string(nvl, key) != value); 183 184 /* Iterate over the nvlist; ensure that it has only our one key. */ 185 it = NULL; 186 ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); 187 ATF_REQUIRE_EQ(type, NV_TYPE_STRING); 188 ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL)); 189 190 nvlist_destroy(nvl); 191 } 192 193 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert); 194 ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert) 195 { 196 nvlist_t *nvl; 197 void *it; 198 const char *key, *subkey; 199 nvlist_t *sublist; 200 const nvlist_t *value; 201 int type; 202 203 key = "test"; 204 subkey = "subkey"; 205 sublist = nvlist_create(0); 206 nvl = nvlist_create(0); 207 208 ATF_REQUIRE(nvl != NULL); 209 ATF_REQUIRE(!nvlist_exists(nvl, key)); 210 211 nvlist_add_null(sublist, subkey); 212 nvlist_add_nvlist(nvl, key, sublist); 213 214 ATF_REQUIRE(!nvlist_empty(nvl)); 215 ATF_REQUIRE(nvlist_exists(nvl, key)); 216 ATF_REQUIRE(nvlist_exists(nvl, "test")); 217 ATF_REQUIRE(nvlist_exists_nvlist(nvl, key)); 218 ATF_REQUIRE(nvlist_exists_nvlist(nvl, "test")); 219 220 value = nvlist_get_nvlist(nvl, key); 221 ATF_REQUIRE(nvlist_exists_null(value, subkey)); 222 223 /* nvlist_add_* is required to clone the value, so check for that. */ 224 ATF_REQUIRE(sublist != value); 225 226 /* Iterate over the nvlist; ensure that it has only our one key. */ 227 it = NULL; 228 ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); 229 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); 230 ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL)); 231 232 nvlist_destroy(sublist); 233 nvlist_destroy(nvl); 234 } 235 236 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__child_with_error); 237 ATF_TEST_CASE_BODY(nvlist_add_nvlist__child_with_error) 238 { 239 nvlist_t *nvl, *parent; 240 241 nvl = nvlist_create(0); 242 parent = nvlist_create(0); 243 244 nvlist_set_error(nvl, EBADF); 245 nvlist_add_nvlist(parent, "test", nvl); 246 ATF_REQUIRE_EQ(nvlist_error(parent), EBADF); 247 248 nvlist_destroy(nvl); 249 nvlist_destroy(parent); 250 } 251 252 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert); 253 ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert) 254 { 255 nvlist_t *nvl; 256 void *it; 257 const char *key; 258 void *value; 259 const void *ret_value; 260 size_t value_size, ret_size; 261 int type; 262 263 key = "binary"; 264 value_size = 13; 265 value = malloc(value_size); 266 memset(value, 0xa5, value_size); 267 nvl = nvlist_create(0); 268 269 ATF_REQUIRE(nvl != NULL); 270 ATF_REQUIRE(!nvlist_exists(nvl, key)); 271 272 nvlist_add_binary(nvl, key, value, value_size); 273 274 ATF_REQUIRE(!nvlist_empty(nvl)); 275 ATF_REQUIRE(nvlist_exists(nvl, key)); 276 ATF_REQUIRE(nvlist_exists(nvl, "binary")); 277 ATF_REQUIRE(nvlist_exists_binary(nvl, key)); 278 ATF_REQUIRE(nvlist_exists_binary(nvl, "binary")); 279 280 ret_value = nvlist_get_binary(nvl, key, &ret_size); 281 ATF_REQUIRE_EQ(value_size, ret_size); 282 ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0); 283 284 /* nvlist_add_* is required to clone the value, so check for that. */ 285 ATF_REQUIRE(value != ret_value); 286 287 /* Iterate over the nvlist; ensure that it has only our one key. */ 288 it = NULL; 289 ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); 290 ATF_REQUIRE_EQ(type, NV_TYPE_BINARY); 291 ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL)); 292 293 nvlist_destroy(nvl); 294 free(value); 295 } 296 297 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__empty_nvlist); 298 ATF_TEST_CASE_BODY(nvlist_clone__empty_nvlist) 299 { 300 nvlist_t *nvl, *clone; 301 302 nvl = nvlist_create(0); 303 ATF_REQUIRE(nvl != NULL); 304 305 clone = nvlist_clone(nvl); 306 ATF_REQUIRE(clone != NULL); 307 ATF_REQUIRE(clone != nvl); 308 ATF_REQUIRE(nvlist_empty(clone)); 309 310 nvlist_destroy(clone); 311 nvlist_destroy(nvl); 312 } 313 314 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nonempty_nvlist); 315 ATF_TEST_CASE_BODY(nvlist_clone__nonempty_nvlist) 316 { 317 nvlist_t *nvl, *clone; 318 const char *key; 319 void *it; 320 uint64_t value; 321 int type; 322 323 nvl = nvlist_create(0); 324 ATF_REQUIRE(nvl != NULL); 325 326 key = "testkey"; 327 value = 684874; 328 nvlist_add_number(nvl, key, value); 329 330 clone = nvlist_clone(nvl); 331 ATF_REQUIRE(clone != NULL); 332 ATF_REQUIRE(clone != nvl); 333 ATF_REQUIRE(nvlist_exists_number(clone, key)); 334 ATF_REQUIRE_EQ(nvlist_get_number(clone, key), value); 335 336 /* Iterate over the nvlist; ensure that it has only our one key. */ 337 it = NULL; 338 ATF_REQUIRE_EQ(strcmp(nvlist_next(clone, &type, &it), key), 0); 339 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); 340 ATF_REQUIRE_EQ(nvlist_next(clone, &type, &it), static_cast<const char *>(NULL)); 341 342 nvlist_destroy(clone); 343 nvlist_destroy(nvl); 344 } 345 346 static const char * const test_subnvlist_key = "nvlist"; 347 348 static const char * const test_string_key = "string"; 349 static const char * const test_string_val = "59525"; 350 351 static nvlist_t* 352 create_test_nvlist(void) 353 { 354 nvlist_t *nvl, *sublist; 355 356 nvl = nvlist_create(0); 357 ATF_REQUIRE(nvl != NULL); 358 359 sublist = nvlist_create(0); 360 ATF_REQUIRE(sublist != NULL); 361 362 nvlist_add_string(sublist, test_string_key, test_string_val); 363 nvlist_move_nvlist(nvl, test_subnvlist_key, sublist); 364 365 return (nvl); 366 } 367 368 static void 369 verify_test_nvlist(const nvlist_t *nvl) 370 { 371 void *it; 372 const nvlist_t *value; 373 int type; 374 375 ATF_REQUIRE(nvlist_exists_nvlist(nvl, test_subnvlist_key)); 376 377 value = nvlist_get_nvlist(nvl, test_subnvlist_key); 378 379 ATF_REQUIRE(nvlist_exists_string(value, test_string_key)); 380 ATF_REQUIRE_EQ(strcmp(nvlist_get_string(value, test_string_key), test_string_val), 0); 381 ATF_REQUIRE(nvlist_get_string(value, test_string_key) != test_string_val); 382 383 /* Iterate over both nvlists; ensure that each has only the one key. */ 384 it = NULL; 385 ATF_REQUIRE_EQ(strcmp(nvlist_next(value, &type, &it), 386 test_string_key), 0); 387 ATF_REQUIRE_EQ(type, NV_TYPE_STRING); 388 ATF_REQUIRE_EQ(nvlist_next(value, &type, &it), static_cast<const char *>(NULL)); 389 390 it = NULL; 391 ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), 392 test_subnvlist_key), 0); 393 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); 394 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), static_cast<const char *>(NULL)); 395 } 396 397 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nested_nvlist); 398 ATF_TEST_CASE_BODY(nvlist_clone__nested_nvlist) 399 { 400 nvlist_t *nvl, *clone; 401 402 nvl = create_test_nvlist(); 403 clone = nvlist_clone(nvl); 404 405 ATF_REQUIRE(clone != NULL); 406 ATF_REQUIRE(clone != nvl); 407 verify_test_nvlist(clone); 408 409 nvlist_destroy(clone); 410 nvlist_destroy(nvl); 411 } 412 413 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__error_nvlist); 414 ATF_TEST_CASE_BODY(nvlist_clone__error_nvlist) 415 { 416 nvlist_t *nvl, *clone; 417 418 nvl = nvlist_create(0); 419 ATF_REQUIRE(nvl != NULL); 420 421 nvlist_set_error(nvl, ENOMEM); 422 423 clone = nvlist_clone(nvl); 424 ATF_REQUIRE(clone == NULL); 425 426 nvlist_destroy(nvl); 427 } 428 429 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__empty_nvlist); 430 ATF_TEST_CASE_BODY(nvlist_pack__empty_nvlist) 431 { 432 nvlist_t *nvl, *unpacked; 433 void *packed; 434 size_t packed_size; 435 436 nvl = nvlist_create(0); 437 ATF_REQUIRE(nvl != NULL); 438 439 packed = nvlist_pack(nvl, &packed_size); 440 ATF_REQUIRE(packed != NULL); 441 442 unpacked = nvlist_unpack(packed, packed_size, 0); 443 ATF_REQUIRE(unpacked != NULL); 444 ATF_REQUIRE(unpacked != nvl); 445 ATF_REQUIRE(nvlist_empty(unpacked)); 446 447 nvlist_destroy(unpacked); 448 nvlist_destroy(nvl); 449 free(packed); 450 } 451 452 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__flags_nvlist); 453 ATF_TEST_CASE_BODY(nvlist_unpack__flags_nvlist) 454 { 455 nvlist_t *nvl, *unpacked; 456 void *packed; 457 size_t packed_size; 458 459 nvl = nvlist_create(NV_FLAG_NO_UNIQUE); 460 ATF_REQUIRE(nvl != NULL); 461 462 nvlist_add_bool(nvl, "name", true); 463 ATF_REQUIRE(!nvlist_empty(nvl)); 464 ATF_REQUIRE(nvlist_exists_bool(nvl, "name")); 465 466 packed = nvlist_pack(nvl, &packed_size); 467 ATF_REQUIRE(packed != NULL); 468 469 unpacked = nvlist_unpack(packed, packed_size, 0); 470 ATF_REQUIRE(unpacked == NULL); 471 472 unpacked = nvlist_unpack(packed, packed_size, NV_FLAG_IGNORE_CASE); 473 ATF_REQUIRE(unpacked == NULL); 474 475 unpacked = nvlist_unpack(packed, packed_size, NV_FLAG_NO_UNIQUE); 476 ATF_REQUIRE(unpacked != NULL); 477 ATF_REQUIRE(unpacked != nvl); 478 ATF_REQUIRE(!nvlist_empty(unpacked)); 479 ATF_REQUIRE(nvlist_exists_bool(unpacked, "name")); 480 481 nvlist_destroy(unpacked); 482 nvlist_destroy(nvl); 483 free(packed); 484 } 485 486 static void 487 verify_null(const nvlist_t *nvl, int type) 488 { 489 490 ATF_REQUIRE_EQ(type, NV_TYPE_NULL); 491 } 492 493 static void 494 verify_number(const nvlist_t *nvl, const char *name, int type, uint64_t value) 495 { 496 497 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); 498 ATF_REQUIRE_EQ(nvlist_get_number(nvl, name), value); 499 } 500 501 static void 502 verify_string(const nvlist_t *nvl, const char *name, int type, 503 const char * value) 504 { 505 506 ATF_REQUIRE_EQ(type, NV_TYPE_STRING); 507 ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, name), value), 0); 508 } 509 510 static void 511 verify_nvlist(const nvlist_t *nvl, const char *name, int type) 512 { 513 514 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); 515 verify_test_nvlist(nvlist_get_nvlist(nvl, name)); 516 } 517 518 static void 519 verify_binary(const nvlist_t *nvl, const char *name, int type, 520 const void * value, size_t size) 521 { 522 const void *actual_value; 523 size_t actual_size; 524 525 ATF_REQUIRE_EQ(type, NV_TYPE_BINARY); 526 actual_value = nvlist_get_binary(nvl, name, &actual_size); 527 ATF_REQUIRE_EQ(size, actual_size); 528 ATF_REQUIRE_EQ(memcmp(value, actual_value, size), 0); 529 } 530 531 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__multiple_values); 532 ATF_TEST_CASE_BODY(nvlist_pack__multiple_values) 533 { 534 std::ostringstream msg; 535 std::set<std::string> keys_seen; 536 nvlist_t *nvl, *unpacked, *nvvalue; 537 const char *nullkey, *numkey, *strkey, *nvkey, *binkey, *name; 538 int numvalue; 539 const char * strvalue; 540 void *binvalue, *packed, *it; 541 size_t binsize, packed_size; 542 int type; 543 544 nvl = nvlist_create(0); 545 546 nullkey = "null"; 547 nvlist_add_null(nvl, nullkey); 548 549 numkey = "number"; 550 numvalue = 939853984; 551 nvlist_add_number(nvl, numkey, numvalue); 552 553 strkey = "string"; 554 strvalue = "jfieutijf"; 555 nvlist_add_string(nvl, strkey, strvalue); 556 557 nvkey = "nvlist"; 558 nvvalue = create_test_nvlist(); 559 nvlist_move_nvlist(nvl, nvkey, nvvalue); 560 561 binkey = "binary"; 562 binsize = 4; 563 binvalue = malloc(binsize); 564 memset(binvalue, 'b', binsize); 565 nvlist_move_binary(nvl, binkey, binvalue, binsize); 566 567 packed = nvlist_pack(nvl, &packed_size); 568 ATF_REQUIRE(packed != NULL); 569 570 unpacked = nvlist_unpack(packed, packed_size, 0); 571 ATF_REQUIRE(unpacked != 0); 572 573 it = NULL; 574 while ((name = nvlist_next(unpacked, &type, &it)) != NULL) { 575 /* Ensure that we see every key only once. */ 576 ATF_REQUIRE_EQ(keys_seen.count(name), 0); 577 578 if (strcmp(name, nullkey) == 0) 579 verify_null(unpacked, type); 580 else if (strcmp(name, numkey) == 0) 581 verify_number(unpacked, name, type, numvalue); 582 else if (strcmp(name, strkey) == 0) 583 verify_string(unpacked, name, type, strvalue); 584 else if (strcmp(name, nvkey) == 0) 585 verify_nvlist(unpacked, name, type); 586 else if (strcmp(name, binkey) == 0) 587 verify_binary(unpacked, name, type, binvalue, binsize); 588 else { 589 msg << "Unexpected key :'" << name << "'"; 590 ATF_FAIL(msg.str().c_str()); 591 } 592 593 keys_seen.insert(name); 594 } 595 596 /* Ensure that we saw every key. */ 597 ATF_REQUIRE_EQ(keys_seen.size(), 5); 598 599 nvlist_destroy(nvl); 600 nvlist_destroy(unpacked); 601 free(packed); 602 } 603 604 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__error_nvlist); 605 ATF_TEST_CASE_BODY(nvlist_pack__error_nvlist) 606 { 607 nvlist_t *nvl; 608 void *packed; 609 size_t size; 610 611 nvl = nvlist_create(0); 612 ATF_REQUIRE(nvl != NULL); 613 614 nvlist_set_error(nvl, ENOMEM); 615 616 packed = nvlist_pack(nvl, &size); 617 ATF_REQUIRE(packed == NULL); 618 619 nvlist_destroy(nvl); 620 } 621 622 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__duplicate_key); 623 ATF_TEST_CASE_BODY(nvlist_unpack__duplicate_key) 624 { 625 nvlist_t *nvl, *unpacked; 626 const char *key1, *key2; 627 void *packed, *keypos; 628 size_t size, keylen; 629 630 nvl = nvlist_create(0); 631 632 key1 = "key1"; 633 keylen = strlen(key1); 634 nvlist_add_number(nvl, key1, 5); 635 636 key2 = "key2"; 637 ATF_REQUIRE_EQ(keylen, strlen(key2)); 638 nvlist_add_number(nvl, key2, 10); 639 640 packed = nvlist_pack(nvl, &size); 641 ATF_REQUIRE(packed != NULL); 642 643 /* 644 * Mangle the packed nvlist by replacing key1 with key2, creating a 645 * packed nvlist with a duplicate key. 646 */ 647 keypos = memmem(packed, size, key1, keylen); 648 ATF_REQUIRE(keypos != NULL); 649 memcpy(keypos, key2, keylen); 650 651 unpacked = nvlist_unpack(packed, size, 0); 652 ATF_REQUIRE(nvlist_error(unpacked) != 0); 653 654 free(packed); 655 nvlist_destroy(nvl); 656 nvlist_destroy(unpacked); 657 } 658 659 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_string__single_insert); 660 ATF_TEST_CASE_BODY(nvlist_move_string__single_insert) 661 { 662 nvlist_t *nvl; 663 const char *key; 664 char *value; 665 666 nvl = nvlist_create(0); 667 ATF_REQUIRE(nvl != NULL); 668 669 key = "testkey"; 670 value = strdup("testval"); 671 ATF_REQUIRE(value != NULL); 672 673 nvlist_move_string(nvl, key, value); 674 ATF_REQUIRE_EQ(nvlist_get_string(nvl, key), value); 675 676 nvlist_destroy(nvl); 677 } 678 679 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__null_child); 680 ATF_TEST_CASE_BODY(nvlist_move_nvlist__null_child) 681 { 682 nvlist_t *parent; 683 684 parent = nvlist_create(0); 685 686 nvlist_move_nvlist(parent, "test", NULL); 687 688 ATF_REQUIRE(nvlist_error(parent) != 0); 689 690 nvlist_destroy(parent); 691 } 692 693 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__child_with_error); 694 ATF_TEST_CASE_BODY(nvlist_move_nvlist__child_with_error) 695 { 696 nvlist_t *nvl, *parent; 697 698 nvl = nvlist_create(0); 699 parent = nvlist_create(0); 700 701 nvlist_set_error(nvl, EBADF); 702 nvlist_move_nvlist(parent, "test", nvl); 703 ATF_REQUIRE_EQ(nvlist_error(parent), EBADF); 704 705 nvlist_destroy(parent); 706 } 707 708 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__single_insert); 709 ATF_TEST_CASE_BODY(nvlist_move_nvlist__single_insert) 710 { 711 nvlist_t *nvl; 712 const char *key; 713 nvlist_t *value; 714 715 nvl = nvlist_create(0); 716 ATF_REQUIRE(nvl != NULL); 717 718 key = "testkey"; 719 value = nvlist_create(0); 720 ATF_REQUIRE(value != NULL); 721 722 nvlist_move_nvlist(nvl, key, value); 723 ATF_REQUIRE_EQ(nvlist_get_nvlist(nvl, key), value); 724 725 nvlist_destroy(nvl); 726 } 727 728 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_binary__single_insert); 729 ATF_TEST_CASE_BODY(nvlist_move_binary__single_insert) 730 { 731 nvlist_t *nvl; 732 const char *key; 733 void *value; 734 size_t size, actual_size; 735 736 nvl = nvlist_create(0); 737 ATF_REQUIRE(nvl != NULL); 738 739 key = "testkey"; 740 size = 73; 741 value = malloc(size); 742 ATF_REQUIRE(value != NULL); 743 744 nvlist_move_binary(nvl, key, value, size); 745 ATF_REQUIRE_EQ(nvlist_get_binary(nvl, key, &actual_size), value); 746 ATF_REQUIRE_EQ(size, actual_size); 747 748 nvlist_destroy(nvl); 749 } 750 751 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__single_remove); 752 ATF_TEST_CASE_BODY(nvlist_take_bool__single_remove) 753 { 754 nvlist_t *nvl; 755 const char *testkey; 756 bool testval; 757 758 nvl = nvlist_create(0); 759 ATF_REQUIRE(nvl != NULL); 760 761 testkey = "boolkey"; 762 testval = false; 763 nvlist_add_bool(nvl, testkey, testval); 764 765 ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval); 766 ATF_REQUIRE(nvlist_empty(nvl)); 767 768 nvlist_destroy(nvl); 769 } 770 771 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__other_keys_unchanged); 772 ATF_TEST_CASE_BODY(nvlist_take_bool__other_keys_unchanged) 773 { 774 nvlist_t *nvl; 775 const char *testkey, *otherkey1, *otherkey2; 776 bool testval, otherval1; 777 nvlist_t *otherval2; 778 779 nvl = nvlist_create(0); 780 ATF_REQUIRE(nvl != NULL); 781 782 testkey = "boolkey"; 783 testval = true; 784 nvlist_add_bool(nvl, testkey, testval); 785 786 otherkey1 = "key1"; 787 otherval1 = false; 788 nvlist_add_bool(nvl, otherkey1, otherval1); 789 790 otherkey2 = "key2"; 791 otherval2 = create_test_nvlist(); 792 nvlist_move_nvlist(nvl, otherkey2, otherval2); 793 794 ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval); 795 796 ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey1)); 797 ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey1), otherval1); 798 799 ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey2)); 800 verify_test_nvlist(nvlist_get_nvlist(nvl, otherkey2)); 801 802 nvlist_destroy(nvl); 803 } 804 805 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__single_remove); 806 ATF_TEST_CASE_BODY(nvlist_take_number__single_remove) 807 { 808 nvlist_t *nvl; 809 const char *testkey; 810 uint64_t testval; 811 812 nvl = nvlist_create(0); 813 ATF_REQUIRE(nvl != NULL); 814 815 testkey = "numkey"; 816 testval = std::numeric_limits<uint64_t>::max(); 817 nvlist_add_number(nvl, testkey, testval); 818 819 ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval); 820 ATF_REQUIRE(nvlist_empty(nvl)); 821 822 nvlist_destroy(nvl); 823 } 824 825 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__other_keys_unchanged); 826 ATF_TEST_CASE_BODY(nvlist_take_number__other_keys_unchanged) 827 { 828 nvlist_t *nvl; 829 const char *testkey, *otherkey1, *otherkey2; 830 uint64_t testval, otherval1; 831 const char *otherval2; 832 833 nvl = nvlist_create(0); 834 ATF_REQUIRE(nvl != NULL); 835 836 otherkey1 = "key1"; 837 otherval1 = 5; 838 nvlist_add_number(nvl, otherkey1, otherval1); 839 840 testkey = "numkey"; 841 testval = 1654; 842 nvlist_add_number(nvl, testkey, testval); 843 844 otherkey2 = "key2"; 845 otherval2 = "string"; 846 nvlist_add_string(nvl, otherkey2, otherval2); 847 848 ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval); 849 850 ATF_REQUIRE(nvlist_exists_number(nvl, otherkey1)); 851 ATF_REQUIRE_EQ(nvlist_get_number(nvl, otherkey1), otherval1); 852 853 ATF_REQUIRE(nvlist_exists_string(nvl, otherkey2)); 854 ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey2), otherval2), 0); 855 856 nvlist_destroy(nvl); 857 } 858 859 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__single_remove); 860 ATF_TEST_CASE_BODY(nvlist_take_string__single_remove) 861 { 862 nvlist_t *nvl; 863 const char *testkey; 864 const char *testval; 865 866 nvl = nvlist_create(0); 867 ATF_REQUIRE(nvl != NULL); 868 869 testkey = "numkey"; 870 testval = "nvlist"; 871 nvlist_add_string(nvl, testkey, testval); 872 873 ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0); 874 ATF_REQUIRE(nvlist_empty(nvl)); 875 876 nvlist_destroy(nvl); 877 } 878 879 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__other_keys_unchanged); 880 ATF_TEST_CASE_BODY(nvlist_take_string__other_keys_unchanged) 881 { 882 nvlist_t *nvl; 883 const char *testkey, *otherkey1, *otherkey2; 884 const char *testval, *otherval1; 885 bool otherval2; 886 887 nvl = nvlist_create(0); 888 ATF_REQUIRE(nvl != NULL); 889 890 otherkey1 = "key1"; 891 otherval1 = "fjdifjdk"; 892 nvlist_add_string(nvl, otherkey1, otherval1); 893 894 otherkey2 = "key2"; 895 otherval2 = true; 896 nvlist_add_bool(nvl, otherkey2, otherval2); 897 898 testkey = "strkey"; 899 testval = "1654"; 900 nvlist_add_string(nvl, testkey, testval); 901 902 ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0); 903 904 ATF_REQUIRE(nvlist_exists_string(nvl, otherkey1)); 905 ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey1), otherval1), 0); 906 907 ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2)); 908 ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2); 909 910 nvlist_destroy(nvl); 911 } 912 913 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__single_remove); 914 ATF_TEST_CASE_BODY(nvlist_take_nvlist__single_remove) 915 { 916 nvlist_t *nvl; 917 const char *testkey; 918 nvlist_t *testval; 919 920 nvl = nvlist_create(0); 921 ATF_REQUIRE(nvl != NULL); 922 923 testkey = "numkey"; 924 testval = create_test_nvlist(); 925 nvlist_move_nvlist(nvl, testkey, testval); 926 927 verify_test_nvlist(nvlist_take_nvlist(nvl, testkey)); 928 ATF_REQUIRE(nvlist_empty(nvl)); 929 930 nvlist_destroy(nvl); 931 } 932 933 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__other_keys_unchanged); 934 ATF_TEST_CASE_BODY(nvlist_take_nvlist__other_keys_unchanged) 935 { 936 nvlist_t *nvl; 937 const char *testkey, *otherkey1, *otherkey2; 938 nvlist_t *testval, *otherval1; 939 940 nvl = nvlist_create(0); 941 ATF_REQUIRE(nvl != NULL); 942 943 testkey = "strkey"; 944 testval = create_test_nvlist(); 945 nvlist_move_nvlist(nvl, testkey, testval); 946 947 otherkey1 = "key1"; 948 otherval1 = nvlist_create(0); 949 nvlist_move_nvlist(nvl, otherkey1, otherval1); 950 951 otherkey2 = "key2"; 952 nvlist_add_null(nvl, otherkey2); 953 954 verify_test_nvlist(nvlist_take_nvlist(nvl, testkey)); 955 956 ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey1)); 957 ATF_REQUIRE(nvlist_empty(nvlist_get_nvlist(nvl, otherkey1))); 958 959 ATF_REQUIRE(nvlist_exists_null(nvl, otherkey2)); 960 961 nvlist_destroy(nvl); 962 } 963 964 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__single_remove); 965 ATF_TEST_CASE_BODY(nvlist_take_binary__single_remove) 966 { 967 nvlist_t *nvl; 968 const char *testkey; 969 void *testval; 970 const void *actual_val; 971 size_t testsize, actual_size; 972 973 nvl = nvlist_create(0); 974 ATF_REQUIRE(nvl != NULL); 975 976 testkey = "numkey"; 977 testsize = 457; 978 testval = malloc(testsize); 979 memset(testval, '5', testsize); 980 nvlist_move_binary(nvl, testkey, testval, testsize); 981 982 actual_val = nvlist_take_binary(nvl, testkey, &actual_size); 983 ATF_REQUIRE_EQ(testsize, actual_size); 984 ATF_REQUIRE_EQ(memcmp(actual_val, testval, testsize), 0); 985 ATF_REQUIRE(nvlist_empty(nvl)); 986 987 nvlist_destroy(nvl); 988 } 989 990 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__other_keys_unchanged); 991 ATF_TEST_CASE_BODY(nvlist_take_binary__other_keys_unchanged) 992 { 993 nvlist_t *nvl; 994 const char *testkey, *otherkey1, *otherkey2; 995 const void *actual_value; 996 char testval[] = "gjiertj"; 997 char otherval1[] = "fdreg"; 998 size_t testsize, othersize, actual_size; 999 bool otherval2; 1000 1001 nvl = nvlist_create(0); 1002 ATF_REQUIRE(nvl != NULL); 1003 1004 otherkey1 = "key1"; 1005 othersize = sizeof(otherval1); 1006 nvlist_add_binary(nvl, otherkey1, otherval1, othersize); 1007 1008 otherkey2 = "key2"; 1009 otherval2 = true; 1010 nvlist_add_bool(nvl, otherkey2, otherval2); 1011 1012 testkey = "strkey"; 1013 testsize = sizeof(testval); 1014 nvlist_add_binary(nvl, testkey, testval, testsize); 1015 1016 actual_value = nvlist_take_binary(nvl, testkey, &actual_size); 1017 ATF_REQUIRE_EQ(testsize, actual_size); 1018 ATF_REQUIRE_EQ(memcmp(actual_value, testval, testsize), 0); 1019 1020 ATF_REQUIRE(nvlist_exists_binary(nvl, otherkey1)); 1021 actual_value = nvlist_get_binary(nvl, otherkey1, &actual_size); 1022 ATF_REQUIRE_EQ(othersize, actual_size); 1023 ATF_REQUIRE_EQ(memcmp(actual_value, otherval1, othersize), 0); 1024 1025 ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2)); 1026 ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2); 1027 1028 nvlist_destroy(nvl); 1029 } 1030 1031 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_null); 1032 ATF_TEST_CASE_BODY(nvlist_free__single_null) 1033 { 1034 nvlist_t *nvl; 1035 const char *key; 1036 1037 nvl = nvlist_create(0); 1038 key = "test"; 1039 nvlist_add_null(nvl, key); 1040 1041 nvlist_free(nvl, key); 1042 ATF_REQUIRE(nvlist_empty(nvl)); 1043 1044 nvlist_destroy(nvl); 1045 } 1046 1047 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_bool); 1048 ATF_TEST_CASE_BODY(nvlist_free__single_bool) 1049 { 1050 nvlist_t *nvl; 1051 const char *key; 1052 1053 nvl = nvlist_create(0); 1054 key = "test"; 1055 nvlist_add_bool(nvl, key, true); 1056 1057 nvlist_free(nvl, key); 1058 ATF_REQUIRE(nvlist_empty(nvl)); 1059 1060 nvlist_destroy(nvl); 1061 } 1062 1063 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_number); 1064 ATF_TEST_CASE_BODY(nvlist_free__single_number) 1065 { 1066 nvlist_t *nvl; 1067 const char *key; 1068 1069 nvl = nvlist_create(0); 1070 key = "test"; 1071 nvlist_add_number(nvl, key, 584); 1072 1073 nvlist_free(nvl, key); 1074 ATF_REQUIRE(nvlist_empty(nvl)); 1075 1076 nvlist_destroy(nvl); 1077 } 1078 1079 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_string); 1080 ATF_TEST_CASE_BODY(nvlist_free__single_string) 1081 { 1082 nvlist_t *nvl; 1083 const char *key; 1084 1085 nvl = nvlist_create(0); 1086 key = "test"; 1087 nvlist_add_string(nvl, key, "gjkfkjd"); 1088 1089 nvlist_free(nvl, key); 1090 ATF_REQUIRE(nvlist_empty(nvl)); 1091 1092 nvlist_destroy(nvl); 1093 } 1094 1095 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_nvlist); 1096 ATF_TEST_CASE_BODY(nvlist_free__single_nvlist) 1097 { 1098 nvlist_t *nvl; 1099 const char *key; 1100 1101 nvl = nvlist_create(0); 1102 key = "test"; 1103 nvlist_add_nvlist(nvl, key, nvlist_create(0)); 1104 1105 nvlist_free(nvl, key); 1106 ATF_REQUIRE(nvlist_empty(nvl)); 1107 1108 nvlist_destroy(nvl); 1109 } 1110 1111 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_binary); 1112 ATF_TEST_CASE_BODY(nvlist_free__single_binary) 1113 { 1114 nvlist_t *nvl; 1115 const char *key; 1116 1117 nvl = nvlist_create(0); 1118 key = "test"; 1119 nvlist_add_binary(nvl, key, "jgjgfd", 6); 1120 1121 nvlist_free(nvl, key); 1122 ATF_REQUIRE(nvlist_empty(nvl)); 1123 1124 nvlist_destroy(nvl); 1125 } 1126 1127 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_null__single_null); 1128 ATF_TEST_CASE_BODY(nvlist_free_null__single_null) 1129 { 1130 nvlist_t *nvl; 1131 const char *key; 1132 1133 nvl = nvlist_create(0); 1134 key = "test"; 1135 nvlist_add_null(nvl, key); 1136 1137 nvlist_free_null(nvl, key); 1138 ATF_REQUIRE(nvlist_empty(nvl)); 1139 1140 nvlist_destroy(nvl); 1141 } 1142 1143 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_bool__single_bool); 1144 ATF_TEST_CASE_BODY(nvlist_free_bool__single_bool) 1145 { 1146 nvlist_t *nvl; 1147 const char *key; 1148 1149 nvl = nvlist_create(0); 1150 key = "test"; 1151 nvlist_add_bool(nvl, key, true); 1152 1153 nvlist_free_bool(nvl, key); 1154 ATF_REQUIRE(nvlist_empty(nvl)); 1155 1156 nvlist_destroy(nvl); 1157 } 1158 1159 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_number__single_number); 1160 ATF_TEST_CASE_BODY(nvlist_free_number__single_number) 1161 { 1162 nvlist_t *nvl; 1163 const char *key; 1164 1165 nvl = nvlist_create(0); 1166 key = "test"; 1167 nvlist_add_number(nvl, key, 584); 1168 1169 nvlist_free_number(nvl, key); 1170 ATF_REQUIRE(nvlist_empty(nvl)); 1171 1172 nvlist_destroy(nvl); 1173 } 1174 1175 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_string__single_string); 1176 ATF_TEST_CASE_BODY(nvlist_free_string__single_string) 1177 { 1178 nvlist_t *nvl; 1179 const char *key; 1180 1181 nvl = nvlist_create(0); 1182 key = "test"; 1183 nvlist_add_string(nvl, key, "gjkfkjd"); 1184 1185 nvlist_free_string(nvl, key); 1186 ATF_REQUIRE(nvlist_empty(nvl)); 1187 1188 nvlist_destroy(nvl); 1189 } 1190 1191 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_nvlist__single_nvlist); 1192 ATF_TEST_CASE_BODY(nvlist_free_nvlist__single_nvlist) 1193 { 1194 nvlist_t *nvl; 1195 const char *key; 1196 1197 nvl = nvlist_create(0); 1198 key = "test"; 1199 nvlist_add_nvlist(nvl, key, nvlist_create(0)); 1200 1201 nvlist_free_nvlist(nvl, key); 1202 ATF_REQUIRE(nvlist_empty(nvl)); 1203 1204 nvlist_destroy(nvl); 1205 } 1206 1207 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_binary__single_binary); 1208 ATF_TEST_CASE_BODY(nvlist_free_binary__single_binary) 1209 { 1210 nvlist_t *nvl; 1211 const char *key; 1212 1213 nvl = nvlist_create(0); 1214 key = "test"; 1215 nvlist_add_binary(nvl, key, "jgjgfd", 6); 1216 1217 nvlist_free_binary(nvl, key); 1218 ATF_REQUIRE(nvlist_empty(nvl)); 1219 1220 nvlist_destroy(nvl); 1221 } 1222 1223 ATF_INIT_TEST_CASES(tp) 1224 { 1225 ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty); 1226 ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert); 1227 ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert); 1228 ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert); 1229 ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert); 1230 ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert); 1231 ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__child_with_error); 1232 ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert); 1233 1234 ATF_ADD_TEST_CASE(tp, nvlist_clone__empty_nvlist); 1235 ATF_ADD_TEST_CASE(tp, nvlist_clone__nonempty_nvlist); 1236 ATF_ADD_TEST_CASE(tp, nvlist_clone__nested_nvlist); 1237 ATF_ADD_TEST_CASE(tp, nvlist_clone__error_nvlist); 1238 1239 ATF_ADD_TEST_CASE(tp, nvlist_pack__empty_nvlist); 1240 ATF_ADD_TEST_CASE(tp, nvlist_pack__multiple_values); 1241 ATF_ADD_TEST_CASE(tp, nvlist_pack__error_nvlist); 1242 ATF_ADD_TEST_CASE(tp, nvlist_unpack__duplicate_key); 1243 ATF_ADD_TEST_CASE(tp, nvlist_unpack__flags_nvlist); 1244 1245 ATF_ADD_TEST_CASE(tp, nvlist_move_string__single_insert); 1246 ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__single_insert); 1247 ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__null_child); 1248 ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__child_with_error); 1249 ATF_ADD_TEST_CASE(tp, nvlist_move_binary__single_insert); 1250 1251 ATF_ADD_TEST_CASE(tp, nvlist_take_bool__single_remove); 1252 ATF_ADD_TEST_CASE(tp, nvlist_take_bool__other_keys_unchanged); 1253 ATF_ADD_TEST_CASE(tp, nvlist_take_number__single_remove); 1254 ATF_ADD_TEST_CASE(tp, nvlist_take_number__other_keys_unchanged); 1255 ATF_ADD_TEST_CASE(tp, nvlist_take_string__single_remove); 1256 ATF_ADD_TEST_CASE(tp, nvlist_take_string__other_keys_unchanged); 1257 ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__single_remove); 1258 ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__other_keys_unchanged); 1259 ATF_ADD_TEST_CASE(tp, nvlist_take_binary__single_remove); 1260 ATF_ADD_TEST_CASE(tp, nvlist_take_binary__other_keys_unchanged); 1261 1262 ATF_ADD_TEST_CASE(tp, nvlist_free__single_null); 1263 ATF_ADD_TEST_CASE(tp, nvlist_free__single_bool); 1264 ATF_ADD_TEST_CASE(tp, nvlist_free__single_number); 1265 ATF_ADD_TEST_CASE(tp, nvlist_free__single_string); 1266 ATF_ADD_TEST_CASE(tp, nvlist_free__single_nvlist); 1267 ATF_ADD_TEST_CASE(tp, nvlist_free__single_binary); 1268 1269 ATF_ADD_TEST_CASE(tp, nvlist_free_null__single_null); 1270 ATF_ADD_TEST_CASE(tp, nvlist_free_bool__single_bool); 1271 ATF_ADD_TEST_CASE(tp, nvlist_free_number__single_number); 1272 ATF_ADD_TEST_CASE(tp, nvlist_free_string__single_string); 1273 ATF_ADD_TEST_CASE(tp, nvlist_free_nvlist__single_nvlist); 1274 ATF_ADD_TEST_CASE(tp, nvlist_free_binary__single_binary); 1275 } 1276