lib/libnv/tests/nv_tests.cc

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