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         ATF_REQUIRE(packed != NULL);
 644
 645         /*
 646          * Mangle the packed nvlist by replacing key1 with key2, creating a
 647          * packed nvlist with a duplicate key.
 648          */
 649         keypos = memmem(packed, size, key1, keylen);
 650         ATF_REQUIRE(keypos != NULL);
 651         memcpy(keypos, key2, keylen);
 652
 653         unpacked = nvlist_unpack(packed, size, 0);
 654         ATF_REQUIRE(nvlist_error(unpacked) != 0);
 655
 656         free(packed);
 657         nvlist_destroy(nvl);
 658         nvlist_destroy(unpacked);
 659 }
 660
 661 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_string__single_insert);
 662 ATF_TEST_CASE_BODY(nvlist_move_string__single_insert)
 663 {
 664         nvlist_t *nvl;
 665         const char *key;
 666         char *value;
 667
 668         nvl = nvlist_create(0);
 669         ATF_REQUIRE(nvl != NULL);
 670
 671         key = "testkey";
 672         value = strdup("testval");
 673         ATF_REQUIRE(value != NULL);
 674
 675         nvlist_move_string(nvl, key, value);
 676         ATF_REQUIRE_EQ(nvlist_get_string(nvl, key), value);
 677
 678         nvlist_destroy(nvl);
 679 }
 680
 681 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__null_child);
 682 ATF_TEST_CASE_BODY(nvlist_move_nvlist__null_child)
 683 {
 684         nvlist_t *parent;
 685
 686         parent = nvlist_create(0);
 687
 688         nvlist_move_nvlist(parent, "test", NULL);
 689
 690         ATF_REQUIRE(nvlist_error(parent) != 0);
 691
 692         nvlist_destroy(parent);
 693 }
 694
 695 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__child_with_error);
 696 ATF_TEST_CASE_BODY(nvlist_move_nvlist__child_with_error)
 697 {
 698         nvlist_t *nvl, *parent;
 699
 700         nvl = nvlist_create(0);
 701         parent = nvlist_create(0);
 702
 703         nvlist_set_error(nvl, EBADF);
 704         nvlist_move_nvlist(parent, "test", nvl);
 705         ATF_REQUIRE_EQ(nvlist_error(parent), EBADF);
 706
 707         nvlist_destroy(parent);
 708 }
 709
 710 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__single_insert);
 711 ATF_TEST_CASE_BODY(nvlist_move_nvlist__single_insert)
 712 {
 713         nvlist_t *nvl;
 714         const char *key;
 715         nvlist_t *value;
 716
 717         nvl = nvlist_create(0);
 718         ATF_REQUIRE(nvl != NULL);
 719
 720         key = "testkey";
 721         value = nvlist_create(0);
 722         ATF_REQUIRE(value != NULL);
 723
 724         nvlist_move_nvlist(nvl, key, value);
 725         ATF_REQUIRE_EQ(nvlist_get_nvlist(nvl, key), value);
 726
 727         nvlist_destroy(nvl);
 728 }
 729
 730 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_binary__single_insert);
 731 ATF_TEST_CASE_BODY(nvlist_move_binary__single_insert)
 732 {
 733         nvlist_t *nvl;
 734         const char *key;
 735         void *value;
 736         size_t size, actual_size;
 737
 738         nvl = nvlist_create(0);
 739         ATF_REQUIRE(nvl != NULL);
 740
 741         key = "testkey";
 742         size = 73;
 743         value = malloc(size);
 744         ATF_REQUIRE(value != NULL);
 745
 746         nvlist_move_binary(nvl, key, value, size);
 747         ATF_REQUIRE_EQ(nvlist_get_binary(nvl, key, &actual_size), value);
 748         ATF_REQUIRE_EQ(size, actual_size);
 749
 750         nvlist_destroy(nvl);
 751 }
 752
 753 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__single_remove);
 754 ATF_TEST_CASE_BODY(nvlist_take_bool__single_remove)
 755 {
 756         nvlist_t *nvl;
 757         const char *testkey;
 758         bool testval;
 759
 760         nvl = nvlist_create(0);
 761         ATF_REQUIRE(nvl != NULL);
 762
 763         testkey = "boolkey";
 764         testval = false;
 765         nvlist_add_bool(nvl, testkey, testval);
 766
 767         ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
 768         ATF_REQUIRE(nvlist_empty(nvl));
 769
 770         nvlist_destroy(nvl);
 771 }
 772
 773 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__other_keys_unchanged);
 774 ATF_TEST_CASE_BODY(nvlist_take_bool__other_keys_unchanged)
 775 {
 776         nvlist_t *nvl;
 777         const char *testkey, *otherkey1, *otherkey2;
 778         bool testval, otherval1;
 779         nvlist_t *otherval2;
 780
 781         nvl = nvlist_create(0);
 782         ATF_REQUIRE(nvl != NULL);
 783
 784         testkey = "boolkey";
 785         testval = true;
 786         nvlist_add_bool(nvl, testkey, testval);
 787
 788         otherkey1 = "key1";
 789         otherval1 = false;
 790         nvlist_add_bool(nvl, otherkey1, otherval1);
 791
 792         otherkey2 = "key2";
 793         otherval2 = create_test_nvlist();
 794         nvlist_move_nvlist(nvl, otherkey2, otherval2);
 795
 796         ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
 797
 798         ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey1));
 799         ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey1), otherval1);
 800
 801         ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey2));
 802         verify_test_nvlist(nvlist_get_nvlist(nvl, otherkey2));
 803
 804         nvlist_destroy(nvl);
 805 }
 806
 807 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__single_remove);
 808 ATF_TEST_CASE_BODY(nvlist_take_number__single_remove)
 809 {
 810         nvlist_t *nvl;
 811         const char *testkey;
 812         uint64_t testval;
 813
 814         nvl = nvlist_create(0);
 815         ATF_REQUIRE(nvl != NULL);
 816
 817         testkey = "numkey";
 818         testval = std::numeric_limits<uint64_t>::max();
 819         nvlist_add_number(nvl, testkey, testval);
 820
 821         ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
 822         ATF_REQUIRE(nvlist_empty(nvl));
 823
 824         nvlist_destroy(nvl);
 825 }
 826
 827 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__other_keys_unchanged);
 828 ATF_TEST_CASE_BODY(nvlist_take_number__other_keys_unchanged)
 829 {
 830         nvlist_t *nvl;
 831         const char *testkey, *otherkey1, *otherkey2;
 832         uint64_t testval, otherval1;
 833         const char *otherval2;
 834
 835         nvl = nvlist_create(0);
 836         ATF_REQUIRE(nvl != NULL);
 837
 838         otherkey1 = "key1";
 839         otherval1 = 5;
 840         nvlist_add_number(nvl, otherkey1, otherval1);
 841
 842         testkey = "numkey";
 843         testval = 1654;
 844         nvlist_add_number(nvl, testkey, testval);
 845
 846         otherkey2 = "key2";
 847         otherval2 = "string";
 848         nvlist_add_string(nvl, otherkey2, otherval2);
 849
 850         ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
 851
 852         ATF_REQUIRE(nvlist_exists_number(nvl, otherkey1));
 853         ATF_REQUIRE_EQ(nvlist_get_number(nvl, otherkey1), otherval1);
 854
 855         ATF_REQUIRE(nvlist_exists_string(nvl, otherkey2));
 856         ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey2), otherval2), 0);
 857
 858         nvlist_destroy(nvl);
 859 }
 860
 861 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__single_remove);
 862 ATF_TEST_CASE_BODY(nvlist_take_string__single_remove)
 863 {
 864         nvlist_t *nvl;
 865         const char *testkey;
 866         const char *testval;
 867
 868         nvl = nvlist_create(0);
 869         ATF_REQUIRE(nvl != NULL);
 870
 871         testkey = "numkey";
 872         testval = "nvlist";
 873         nvlist_add_string(nvl, testkey, testval);
 874
 875         ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
 876         ATF_REQUIRE(nvlist_empty(nvl));
 877
 878         nvlist_destroy(nvl);
 879 }
 880
 881 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__other_keys_unchanged);
 882 ATF_TEST_CASE_BODY(nvlist_take_string__other_keys_unchanged)
 883 {
 884         nvlist_t *nvl;
 885         const char *testkey, *otherkey1, *otherkey2;
 886         const char *testval, *otherval1;
 887         bool otherval2;
 888
 889         nvl = nvlist_create(0);
 890         ATF_REQUIRE(nvl != NULL);
 891
 892         otherkey1 = "key1";
 893         otherval1 = "fjdifjdk";
 894         nvlist_add_string(nvl, otherkey1, otherval1);
 895
 896         otherkey2 = "key2";
 897         otherval2 = true;
 898         nvlist_add_bool(nvl, otherkey2, otherval2);
 899
 900         testkey = "strkey";
 901         testval = "1654";
 902         nvlist_add_string(nvl, testkey, testval);
 903
 904         ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
 905
 906         ATF_REQUIRE(nvlist_exists_string(nvl, otherkey1));
 907         ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey1), otherval1), 0);
 908
 909         ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
 910         ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
 911
 912         nvlist_destroy(nvl);
 913 }
 914
 915 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__single_remove);
 916 ATF_TEST_CASE_BODY(nvlist_take_nvlist__single_remove)
 917 {
 918         nvlist_t *nvl;
 919         const char *testkey;
 920         nvlist_t *testval;
 921
 922         nvl = nvlist_create(0);
 923         ATF_REQUIRE(nvl != NULL);
 924
 925         testkey = "numkey";
 926         testval = create_test_nvlist();
 927         nvlist_move_nvlist(nvl, testkey, testval);
 928
 929         verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
 930         ATF_REQUIRE(nvlist_empty(nvl));
 931
 932         nvlist_destroy(nvl);
 933 }
 934
 935 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__other_keys_unchanged);
 936 ATF_TEST_CASE_BODY(nvlist_take_nvlist__other_keys_unchanged)
 937 {
 938         nvlist_t *nvl;
 939         const char *testkey, *otherkey1, *otherkey2;
 940         nvlist_t *testval, *otherval1;
 941
 942         nvl = nvlist_create(0);
 943         ATF_REQUIRE(nvl != NULL);
 944
 945         testkey = "strkey";
 946         testval = create_test_nvlist();
 947         nvlist_move_nvlist(nvl, testkey, testval);
 948
 949         otherkey1 = "key1";
 950         otherval1 = nvlist_create(0);
 951         nvlist_move_nvlist(nvl, otherkey1, otherval1);
 952
 953         otherkey2 = "key2";
 954         nvlist_add_null(nvl, otherkey2);
 955
 956         verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
 957
 958         ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey1));
 959         ATF_REQUIRE(nvlist_empty(nvlist_get_nvlist(nvl, otherkey1)));
 960
 961         ATF_REQUIRE(nvlist_exists_null(nvl, otherkey2));
 962
 963         nvlist_destroy(nvl);
 964 }
 965
 966 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__single_remove);
 967 ATF_TEST_CASE_BODY(nvlist_take_binary__single_remove)
 968 {
 969         nvlist_t *nvl;
 970         const char *testkey;
 971         void *testval;
 972         const void *actual_val;
 973         size_t testsize, actual_size;
 974
 975         nvl = nvlist_create(0);
 976         ATF_REQUIRE(nvl != NULL);
 977
 978         testkey = "numkey";
 979         testsize = 457;
 980         testval = malloc(testsize);
 981         memset(testval, '5', testsize);
 982         nvlist_move_binary(nvl, testkey, testval, testsize);
 983
 984         actual_val = nvlist_take_binary(nvl, testkey, &actual_size);
 985         ATF_REQUIRE_EQ(testsize, actual_size);
 986         ATF_REQUIRE_EQ(memcmp(actual_val, testval, testsize), 0);
 987         ATF_REQUIRE(nvlist_empty(nvl));
 988
 989         nvlist_destroy(nvl);
 990 }
 991
 992 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__other_keys_unchanged);
 993 ATF_TEST_CASE_BODY(nvlist_take_binary__other_keys_unchanged)
 994 {
 995         nvlist_t *nvl;
 996         const char *testkey, *otherkey1, *otherkey2;
 997         const void *actual_value;
 998         char testval[] = "gjiertj";
 999         char otherval1[] = "fdreg";
1000         size_t testsize, othersize, actual_size;
1001         bool otherval2;
1002
1003         nvl = nvlist_create(0);
1004         ATF_REQUIRE(nvl != NULL);
1005
1006         otherkey1 = "key1";
1007         othersize = sizeof(otherval1);
1008         nvlist_add_binary(nvl, otherkey1, otherval1, othersize);
1009
1010         otherkey2 = "key2";
1011         otherval2 = true;
1012         nvlist_add_bool(nvl, otherkey2, otherval2);
1013
1014         testkey = "strkey";
1015         testsize = sizeof(testval);
1016         nvlist_add_binary(nvl, testkey, testval, testsize);
1017
1018         actual_value = nvlist_take_binary(nvl, testkey, &actual_size);
1019         ATF_REQUIRE_EQ(testsize, actual_size);
1020         ATF_REQUIRE_EQ(memcmp(actual_value, testval, testsize), 0);
1021
1022         ATF_REQUIRE(nvlist_exists_binary(nvl, otherkey1));
1023         actual_value = nvlist_get_binary(nvl, otherkey1, &actual_size);
1024         ATF_REQUIRE_EQ(othersize, actual_size);
1025         ATF_REQUIRE_EQ(memcmp(actual_value, otherval1, othersize), 0);
1026
1027         ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
1028         ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
1029
1030         nvlist_destroy(nvl);
1031 }
1032
1033 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_null);
1034 ATF_TEST_CASE_BODY(nvlist_free__single_null)
1035 {
1036         nvlist_t *nvl;
1037         const char *key;
1038
1039         nvl = nvlist_create(0);
1040         key = "test";
1041         nvlist_add_null(nvl, key);
1042
1043         nvlist_free(nvl, key);
1044         ATF_REQUIRE(nvlist_empty(nvl));
1045
1046         nvlist_destroy(nvl);
1047 }
1048
1049 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_bool);
1050 ATF_TEST_CASE_BODY(nvlist_free__single_bool)
1051 {
1052         nvlist_t *nvl;
1053         const char *key;
1054
1055         nvl = nvlist_create(0);
1056         key = "test";
1057         nvlist_add_bool(nvl, key, true);
1058
1059         nvlist_free(nvl, key);
1060         ATF_REQUIRE(nvlist_empty(nvl));
1061
1062         nvlist_destroy(nvl);
1063 }
1064
1065 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_number);
1066 ATF_TEST_CASE_BODY(nvlist_free__single_number)
1067 {
1068         nvlist_t *nvl;
1069         const char *key;
1070
1071         nvl = nvlist_create(0);
1072         key = "test";
1073         nvlist_add_number(nvl, key, 584);
1074
1075         nvlist_free(nvl, key);
1076         ATF_REQUIRE(nvlist_empty(nvl));
1077
1078         nvlist_destroy(nvl);
1079 }
1080
1081 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_string);
1082 ATF_TEST_CASE_BODY(nvlist_free__single_string)
1083 {
1084         nvlist_t *nvl;
1085         const char *key;
1086
1087         nvl = nvlist_create(0);
1088         key = "test";
1089         nvlist_add_string(nvl, key, "gjkfkjd");
1090
1091         nvlist_free(nvl, key);
1092         ATF_REQUIRE(nvlist_empty(nvl));
1093
1094         nvlist_destroy(nvl);
1095 }
1096
1097 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_nvlist);
1098 ATF_TEST_CASE_BODY(nvlist_free__single_nvlist)
1099 {
1100         nvlist_t *nvl;
1101         const char *key;
1102
1103         nvl = nvlist_create(0);
1104         key = "test";
1105         nvlist_add_nvlist(nvl, key, nvlist_create(0));
1106
1107         nvlist_free(nvl, key);
1108         ATF_REQUIRE(nvlist_empty(nvl));
1109
1110         nvlist_destroy(nvl);
1111 }
1112
1113 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_binary);
1114 ATF_TEST_CASE_BODY(nvlist_free__single_binary)
1115 {
1116         nvlist_t *nvl;
1117         const char *key;
1118
1119         nvl = nvlist_create(0);
1120         key = "test";
1121         nvlist_add_binary(nvl, key, "jgjgfd", 6);
1122
1123         nvlist_free(nvl, key);
1124         ATF_REQUIRE(nvlist_empty(nvl));
1125
1126         nvlist_destroy(nvl);
1127 }
1128
1129 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_null__single_null);
1130 ATF_TEST_CASE_BODY(nvlist_free_null__single_null)
1131 {
1132         nvlist_t *nvl;
1133         const char *key;
1134
1135         nvl = nvlist_create(0);
1136         key = "test";
1137         nvlist_add_null(nvl, key);
1138
1139         nvlist_free_null(nvl, key);
1140         ATF_REQUIRE(nvlist_empty(nvl));
1141
1142         nvlist_destroy(nvl);
1143 }
1144
1145 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_bool__single_bool);
1146 ATF_TEST_CASE_BODY(nvlist_free_bool__single_bool)
1147 {
1148         nvlist_t *nvl;
1149         const char *key;
1150
1151         nvl = nvlist_create(0);
1152         key = "test";
1153         nvlist_add_bool(nvl, key, true);
1154
1155         nvlist_free_bool(nvl, key);
1156         ATF_REQUIRE(nvlist_empty(nvl));
1157
1158         nvlist_destroy(nvl);
1159 }
1160
1161 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_number__single_number);
1162 ATF_TEST_CASE_BODY(nvlist_free_number__single_number)
1163 {
1164         nvlist_t *nvl;
1165         const char *key;
1166
1167         nvl = nvlist_create(0);
1168         key = "test";
1169         nvlist_add_number(nvl, key, 584);
1170
1171         nvlist_free_number(nvl, key);
1172         ATF_REQUIRE(nvlist_empty(nvl));
1173
1174         nvlist_destroy(nvl);
1175 }
1176
1177 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_string__single_string);
1178 ATF_TEST_CASE_BODY(nvlist_free_string__single_string)
1179 {
1180         nvlist_t *nvl;
1181         const char *key;
1182
1183         nvl = nvlist_create(0);
1184         key = "test";
1185         nvlist_add_string(nvl, key, "gjkfkjd");
1186
1187         nvlist_free_string(nvl, key);
1188         ATF_REQUIRE(nvlist_empty(nvl));
1189
1190         nvlist_destroy(nvl);
1191 }
1192
1193 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_nvlist__single_nvlist);
1194 ATF_TEST_CASE_BODY(nvlist_free_nvlist__single_nvlist)
1195 {
1196         nvlist_t *nvl;
1197         const char *key;
1198
1199         nvl = nvlist_create(0);
1200         key = "test";
1201         nvlist_add_nvlist(nvl, key, nvlist_create(0));
1202
1203         nvlist_free_nvlist(nvl, key);
1204         ATF_REQUIRE(nvlist_empty(nvl));
1205
1206         nvlist_destroy(nvl);
1207 }
1208
1209 ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_binary__single_binary);
1210 ATF_TEST_CASE_BODY(nvlist_free_binary__single_binary)
1211 {
1212         nvlist_t *nvl;
1213         const char *key;
1214
1215         nvl = nvlist_create(0);
1216         key = "test";
1217         nvlist_add_binary(nvl, key, "jgjgfd", 6);
1218
1219         nvlist_free_binary(nvl, key);
1220         ATF_REQUIRE(nvlist_empty(nvl));
1221
1222         nvlist_destroy(nvl);
1223 }
1224
1225 ATF_INIT_TEST_CASES(tp)
1226 {
1227         ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty);
1228         ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert);
1229         ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert);
1230         ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert);
1231         ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert);
1232         ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert);
1233         ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__child_with_error);
1234         ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert);
1235
1236         ATF_ADD_TEST_CASE(tp, nvlist_clone__empty_nvlist);
1237         ATF_ADD_TEST_CASE(tp, nvlist_clone__nonempty_nvlist);
1238         ATF_ADD_TEST_CASE(tp, nvlist_clone__nested_nvlist);
1239         ATF_ADD_TEST_CASE(tp, nvlist_clone__error_nvlist);
1240
1241         ATF_ADD_TEST_CASE(tp, nvlist_pack__empty_nvlist);
1242         ATF_ADD_TEST_CASE(tp, nvlist_pack__multiple_values);
1243         ATF_ADD_TEST_CASE(tp, nvlist_pack__error_nvlist);
1244         ATF_ADD_TEST_CASE(tp, nvlist_unpack__duplicate_key);
1245         ATF_ADD_TEST_CASE(tp, nvlist_unpack__flags_nvlist);
1246
1247         ATF_ADD_TEST_CASE(tp, nvlist_move_string__single_insert);
1248         ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__single_insert);
1249         ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__null_child);
1250         ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__child_with_error);
1251         ATF_ADD_TEST_CASE(tp, nvlist_move_binary__single_insert);
1252
1253         ATF_ADD_TEST_CASE(tp, nvlist_take_bool__single_remove);
1254         ATF_ADD_TEST_CASE(tp, nvlist_take_bool__other_keys_unchanged);
1255         ATF_ADD_TEST_CASE(tp, nvlist_take_number__single_remove);
1256         ATF_ADD_TEST_CASE(tp, nvlist_take_number__other_keys_unchanged);
1257         ATF_ADD_TEST_CASE(tp, nvlist_take_string__single_remove);
1258         ATF_ADD_TEST_CASE(tp, nvlist_take_string__other_keys_unchanged);
1259         ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__single_remove);
1260         ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__other_keys_unchanged);
1261         ATF_ADD_TEST_CASE(tp, nvlist_take_binary__single_remove);
1262         ATF_ADD_TEST_CASE(tp, nvlist_take_binary__other_keys_unchanged);
1263
1264         ATF_ADD_TEST_CASE(tp, nvlist_free__single_null);
1265         ATF_ADD_TEST_CASE(tp, nvlist_free__single_bool);
1266         ATF_ADD_TEST_CASE(tp, nvlist_free__single_number);
1267         ATF_ADD_TEST_CASE(tp, nvlist_free__single_string);
1268         ATF_ADD_TEST_CASE(tp, nvlist_free__single_nvlist);
1269         ATF_ADD_TEST_CASE(tp, nvlist_free__single_binary);
1270
1271         ATF_ADD_TEST_CASE(tp, nvlist_free_null__single_null);
1272         ATF_ADD_TEST_CASE(tp, nvlist_free_bool__single_bool);
1273         ATF_ADD_TEST_CASE(tp, nvlist_free_number__single_number);
1274         ATF_ADD_TEST_CASE(tp, nvlist_free_string__single_string);
1275         ATF_ADD_TEST_CASE(tp, nvlist_free_nvlist__single_nvlist);
1276         ATF_ADD_TEST_CASE(tp, nvlist_free_binary__single_binary);
1277 }