Index: user/ngie/stable-10-libnv/lib/libnv/tests/Makefile
===================================================================
--- user/ngie/stable-10-libnv/lib/libnv/tests/Makefile	(revision 292633)
+++ user/ngie/stable-10-libnv/lib/libnv/tests/Makefile	(revision 292634)
@@ -1,17 +1,21 @@
 # $FreeBSD$
 
 TESTSDIR=	${TESTSBASE}/lib/libnv
 
+ATF_TESTS_CXX=	\
+	dnv_tests \
+	nv_tests \
+
 TAP_TESTS_C+=	nvlist_add_test
 TAP_TESTS_C+=	nvlist_exists_test
 TAP_TESTS_C+=	nvlist_free_test
 TAP_TESTS_C+=	nvlist_get_test
 TAP_TESTS_C+=	nvlist_move_test
 TAP_TESTS_C+=	nvlist_send_recv_test
 
 DPADD+=		${LIBNV}
 LDADD+=		-lnv
 
-WARNS?=		6
+WARNS?=		3
 
 .include <bsd.test.mk>
Index: user/ngie/stable-10-libnv/lib/libnv/tests/dnv_tests.cc
===================================================================
--- user/ngie/stable-10-libnv/lib/libnv/tests/dnv_tests.cc	(nonexistent)
+++ user/ngie/stable-10-libnv/lib/libnv/tests/dnv_tests.cc	(revision 292634)
@@ -0,0 +1,577 @@
+/*-
+ * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <atf-c++.hpp>
+#include <dnv.h>
+#include <nv.h>
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_bool__present);
+ATF_TEST_CASE_BODY(dnvlist_get_bool__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	bool value;
+
+	nvl = nvlist_create(0);
+
+	key = "name";
+	value = true;
+	nvlist_add_bool(nvl, key, value);
+
+	ATF_REQUIRE_EQ(dnvlist_get_bool(nvl, key, false), value);
+	ATF_REQUIRE_EQ(dnvlist_getf_bool(nvl, false, "%c%s", 'n', "ame"), value);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_bool__default_value);
+ATF_TEST_CASE_BODY(dnvlist_get_bool__default_value)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	key = "123";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE_EQ(dnvlist_get_bool(nvl, key, false), false);
+	ATF_REQUIRE_EQ(dnvlist_getf_bool(nvl, true, "%d", 123), true);
+
+	nvlist_add_bool(nvl, key, true);
+
+	ATF_REQUIRE_EQ(dnvlist_get_bool(nvl, "otherkey", true), true);
+	ATF_REQUIRE_EQ(dnvlist_getf_bool(nvl, false, "%d%c", 12, 'c'), false);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_number__present);
+ATF_TEST_CASE_BODY(dnvlist_get_number__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	uint64_t value;
+
+	nvl = nvlist_create(0);
+
+	key = "key";
+	value = 48952;
+	nvlist_add_number(nvl, key, value);
+
+	ATF_REQUIRE_EQ(dnvlist_get_number(nvl, key, 19), value);
+	ATF_REQUIRE_EQ(dnvlist_getf_number(nvl, 65, "key"), value);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_number__default_value);
+ATF_TEST_CASE_BODY(dnvlist_get_number__default_value)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	key = "123";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE_EQ(dnvlist_get_number(nvl, key, 5), 5);
+	ATF_REQUIRE_EQ(dnvlist_getf_number(nvl, 12, "%s", key), 12);
+
+	nvlist_add_number(nvl, key, 24841);
+
+	ATF_REQUIRE_EQ(dnvlist_get_number(nvl, "hthth", 184), 184);
+	ATF_REQUIRE_EQ(dnvlist_getf_number(nvl, 5641, "%d", 1234), 5641);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_string__present);
+ATF_TEST_CASE_BODY(dnvlist_get_string__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	const char *value, *actual_value;
+
+	nvl = nvlist_create(0);
+
+	key = "string";
+	value = "fjdojfdi";
+	nvlist_add_string(nvl, key, value);
+
+	ATF_REQUIRE_EQ(strcmp(dnvlist_get_string(nvl, key, "g"), value), 0);
+
+	actual_value = dnvlist_getf_string(nvl, "rs", "%s", key);
+	ATF_REQUIRE_EQ(strcmp(actual_value, value), 0);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_string__default_value);
+ATF_TEST_CASE_BODY(dnvlist_get_string__default_value)
+{
+	nvlist_t *nvl;
+	const char *key;
+	const char *actual_value;
+
+	key = "123";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE_EQ(strcmp(dnvlist_get_string(nvl, key, "bar"), "bar"), 0);
+
+	actual_value = dnvlist_getf_string(nvl, "d", "%s", key);
+	ATF_REQUIRE_EQ(strcmp(actual_value, "d"), 0);
+
+	nvlist_add_string(nvl, key, "cxhweh");
+
+	ATF_REQUIRE_EQ(strcmp(dnvlist_get_string(nvl, "hthth", "fd"), "fd"), 0);
+	actual_value = dnvlist_getf_string(nvl, "5", "%s", "5");
+	ATF_REQUIRE_EQ(strcmp("5", "5"), 0);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_nvlist__present);
+ATF_TEST_CASE_BODY(dnvlist_get_nvlist__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	nvlist_t *value;
+	const nvlist_t *actual_value;
+
+	nvl = nvlist_create(0);
+
+	key = "nvlist";
+	value = nvlist_create(0);
+	nvlist_move_nvlist(nvl, key, value);
+
+	actual_value = dnvlist_get_nvlist(nvl, key, NULL);
+	ATF_REQUIRE(actual_value != NULL);
+	ATF_REQUIRE(nvlist_empty(actual_value));
+
+	actual_value = dnvlist_getf_nvlist(nvl, NULL, "%s", key);
+	ATF_REQUIRE(actual_value != NULL);
+	ATF_REQUIRE(nvlist_empty(actual_value));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_nvlist__default_value);
+ATF_TEST_CASE_BODY(dnvlist_get_nvlist__default_value)
+{
+	nvlist_t *nvl;
+	const char *key;
+	nvlist_t *dummy;
+
+	key = "123";
+	nvl = nvlist_create(0);
+	dummy = nvlist_create(0);
+
+	ATF_REQUIRE_EQ(dnvlist_get_nvlist(nvl, key, dummy), dummy);
+	ATF_REQUIRE_EQ(dnvlist_getf_nvlist(nvl, dummy, "%s", key), dummy);
+
+	nvlist_move_nvlist(nvl, key, nvlist_create(0));
+	ATF_REQUIRE_EQ(dnvlist_get_nvlist(nvl, "456", dummy), dummy);
+	ATF_REQUIRE_EQ(dnvlist_getf_nvlist(nvl, dummy, "%s", "gh"), dummy);
+
+	nvlist_destroy(nvl);
+}
+
+static void
+set_const_binary_value(const void *&value, size_t &size, const char *str)
+{
+
+	value = str;
+	size = strlen(str) + 1; /* +1 to include '\0' */
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_binary__present);
+ATF_TEST_CASE_BODY(dnvlist_get_binary__present)
+{
+	nvlist_t *nvl;
+	const char *k;
+	const void *value, *actual_value;
+	size_t value_size, actual_size;
+
+	nvl = nvlist_create(0);
+
+	k = "binary";
+	set_const_binary_value(value, value_size, "fjdojfdi");
+	nvlist_add_binary(nvl, k, value, value_size);
+
+	actual_value = dnvlist_get_binary(nvl, k, &actual_size, "g", 1);
+	ATF_REQUIRE_EQ(value_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, value, actual_size), 0);
+
+	actual_value = dnvlist_getf_binary(nvl, &actual_size, "g", 1, "%s", k);
+	ATF_REQUIRE_EQ(value_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, value, actual_size), 0);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_binary__default_value);
+ATF_TEST_CASE_BODY(dnvlist_get_binary__default_value)
+{
+	nvlist_t *nvl;
+	const char *key;
+	const void *default_value, *actual_value;
+	size_t default_size, actual_size;
+
+	key = "123";
+	nvl = nvlist_create(0);
+
+	set_const_binary_value(default_value, default_size, "bar");
+	actual_value = dnvlist_get_binary(nvl, key, &actual_size, default_value,
+	    default_size);
+	ATF_REQUIRE_EQ(default_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, default_value, actual_size), 0);
+
+	set_const_binary_value(default_value, default_size, "atf");
+	actual_value = dnvlist_getf_binary(nvl, &actual_size, default_value,
+	    default_size, "%s", key);
+	ATF_REQUIRE_EQ(default_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, default_value, actual_size), 0);
+
+	nvlist_add_binary(nvl, key, "test", 4);
+
+	set_const_binary_value(default_value, default_size, "bthrg");
+	actual_value = dnvlist_get_binary(nvl, "k", &actual_size, default_value,
+	    default_size);
+	ATF_REQUIRE_EQ(default_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, default_value, actual_size), 0);
+
+	set_const_binary_value(default_value, default_size,
+	     "rrhgrythtyrtgbrhgrtdsvdfbtjlkul");
+	actual_value = dnvlist_getf_binary(nvl, &actual_size, default_value,
+	    default_size, "s");
+	ATF_REQUIRE_EQ(default_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, default_value, actual_size), 0);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_bool__present);
+ATF_TEST_CASE_BODY(dnvlist_take_bool__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	bool value;
+
+	nvl = nvlist_create(0);
+
+	key = "name";
+	value = true;
+	nvlist_add_bool(nvl, key, value);
+
+	ATF_REQUIRE_EQ(dnvlist_take_bool(nvl, key, false), value);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_bool__empty);
+ATF_TEST_CASE_BODY(dnvlist_take_bool__empty)
+{
+	nvlist_t *nvl;
+
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE_EQ(dnvlist_take_bool(nvl, "123", false), false);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_bool__default_value);
+ATF_TEST_CASE_BODY(dnvlist_take_bool__default_value)
+{
+	nvlist_t *nvl;
+
+	nvl = nvlist_create(0);
+	nvlist_add_bool(nvl, "key", true);
+
+	ATF_REQUIRE_EQ(dnvlist_take_bool(nvl, "otherkey", true), true);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_number__present);
+ATF_TEST_CASE_BODY(dnvlist_take_number__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	uint64_t value;
+
+	nvl = nvlist_create(0);
+
+	key = "name";
+	value = 194154;
+	nvlist_add_number(nvl, key, value);
+
+	ATF_REQUIRE_EQ(dnvlist_take_number(nvl, key, 2), value);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_number__empty);
+ATF_TEST_CASE_BODY(dnvlist_take_number__empty)
+{
+	nvlist_t *nvl;
+
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE_EQ(dnvlist_take_number(nvl, "123", 126484), 126484);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_number__default_value);
+ATF_TEST_CASE_BODY(dnvlist_take_number__default_value)
+{
+	nvlist_t *nvl;
+
+	nvl = nvlist_create(0);
+	nvlist_add_number(nvl, "key", 12);
+
+	ATF_REQUIRE_EQ(dnvlist_take_number(nvl, "otherkey", 13), 13);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_string__present);
+ATF_TEST_CASE_BODY(dnvlist_take_string__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	const char *value;
+	char *default_val, *actual_val;
+
+	nvl = nvlist_create(0);
+
+	key = "name";
+	value = "wrowm";
+	default_val = strdup("default");
+	nvlist_add_string(nvl, key, value);
+
+	actual_val = dnvlist_take_string(nvl, key, default_val);
+	ATF_REQUIRE_EQ(strcmp(actual_val, value), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	free(actual_val);
+	free(default_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_string__empty);
+ATF_TEST_CASE_BODY(dnvlist_take_string__empty)
+{
+	nvlist_t *nvl;
+	char *default_val, *actual_val;
+
+	nvl = nvlist_create(0);
+	default_val = strdup("");
+
+	actual_val = dnvlist_take_string(nvl, "123", default_val);
+	ATF_REQUIRE_EQ(strcmp(actual_val, default_val), 0);
+
+	free(actual_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_string__default_value);
+ATF_TEST_CASE_BODY(dnvlist_take_string__default_value)
+{
+	nvlist_t *nvl;
+	char *default_val, *actual_val;
+
+	nvl = nvlist_create(0);
+	nvlist_add_string(nvl, "key", "foobar");
+	default_val = strdup("other");
+
+	actual_val = dnvlist_take_string(nvl, "otherkey", default_val);
+	ATF_REQUIRE_EQ(strcmp(actual_val, default_val), 0);
+
+	free(actual_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_nvlist__present);
+ATF_TEST_CASE_BODY(dnvlist_take_nvlist__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	nvlist_t *value, *default_val, *actual_val;
+
+	nvl = nvlist_create(0);
+
+	key = "name";
+	value = nvlist_create(0);
+	default_val = nvlist_create(0);
+	nvlist_move_nvlist(nvl, key, value);
+
+	actual_val = dnvlist_take_nvlist(nvl, key, default_val);
+	ATF_REQUIRE_EQ(actual_val, value);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	free(actual_val);
+	free(default_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_nvlist__empty);
+ATF_TEST_CASE_BODY(dnvlist_take_nvlist__empty)
+{
+	nvlist_t *nvl, *actual_val;
+
+	nvl = nvlist_create(0);
+
+	actual_val = dnvlist_take_nvlist(nvl, "123", NULL);
+	ATF_REQUIRE_EQ(actual_val, NULL);
+
+	free(actual_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_nvlist__default_value);
+ATF_TEST_CASE_BODY(dnvlist_take_nvlist__default_value)
+{
+	nvlist_t *nvl;
+	nvlist_t *default_val, *actual_val;
+
+	nvl = nvlist_create(0);
+	nvlist_move_nvlist(nvl, "key", nvlist_create(0));
+	default_val = nvlist_create(0);
+
+	actual_val = dnvlist_take_nvlist(nvl, "otherkey", default_val);
+	ATF_REQUIRE_EQ(actual_val, default_val);
+
+	free(actual_val);
+	nvlist_destroy(nvl);
+}
+
+static void
+set_binary_value(void *&value, size_t &size, const char *str)
+{
+
+	value = strdup(str);
+	size = strlen(str) + 1; /* +1 to include '\0' */
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_binary__present);
+ATF_TEST_CASE_BODY(dnvlist_take_binary__present)
+{
+	nvlist_t *nvl;
+	const char *key;
+	void *value, *default_val, *actual_val;
+	size_t value_size, default_size, actual_size;
+
+	nvl = nvlist_create(0);
+
+	key = "name";
+	set_binary_value(value, value_size, "fkdojvmo908");
+	set_binary_value(default_val, default_size, "16546");
+	nvlist_add_binary(nvl, key, value, value_size);
+
+	actual_val = dnvlist_take_binary(nvl, key, &actual_size, default_val,
+	    default_size);
+	ATF_REQUIRE_EQ(value_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_val, value, value_size), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	free(actual_val);
+	free(default_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_binary__empty);
+ATF_TEST_CASE_BODY(dnvlist_take_binary__empty)
+{
+	nvlist_t *nvl;
+	void *default_val, *actual_val;
+	size_t default_size, actual_size;
+
+	nvl = nvlist_create(0);
+	set_binary_value(default_val, default_size, "\xa8\x89\x49\xff\xe2\x08");
+
+	actual_val = dnvlist_take_binary(nvl, "123", &actual_size, default_val,
+	    default_size);
+	ATF_REQUIRE_EQ(default_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_val, default_val, actual_size), 0);
+
+	free(actual_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_binary__default_value);
+ATF_TEST_CASE_BODY(dnvlist_take_binary__default_value)
+{
+	nvlist_t *nvl;
+	void *default_val, *actual_val;
+	size_t default_size, actual_size;
+
+	nvl = nvlist_create(0);
+	nvlist_add_binary(nvl, "key", "foobar", 6);
+	set_binary_value(default_val, default_size, "vbhag");
+
+	actual_val = dnvlist_take_binary(nvl, "otherkey", &actual_size,
+	    default_val, default_size);
+	ATF_REQUIRE_EQ(default_size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_val, default_val, default_size), 0);
+
+	free(actual_val);
+	nvlist_destroy(nvl);
+}
+
+ATF_INIT_TEST_CASES(tp)
+{
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_bool__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_bool__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_number__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_number__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_string__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_string__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_nvlist__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_nvlist__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_binary__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_get_binary__default_value);
+
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_bool__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_bool__empty);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_bool__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_number__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_number__empty);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_number__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_string__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_string__empty);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_string__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_nvlist__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_nvlist__empty);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_nvlist__default_value);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_binary__present);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_binary__empty);
+	ATF_ADD_TEST_CASE(tp, dnvlist_take_binary__default_value);
+}

Property changes on: user/ngie/stable-10-libnv/lib/libnv/tests/dnv_tests.cc
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: user/ngie/stable-10-libnv/lib/libnv/tests/nv_tests.cc
===================================================================
--- user/ngie/stable-10-libnv/lib/libnv/tests/nv_tests.cc	(nonexistent)
+++ user/ngie/stable-10-libnv/lib/libnv/tests/nv_tests.cc	(revision 292634)
@@ -0,0 +1,2961 @@
+/*-
+ * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <atf-c++.hpp>
+#include <nv.h>
+
+#include <errno.h>
+#include <limits>
+#include <set>
+#include <sstream>
+#include <string>
+
+/*
+ * Test that a newly created nvlist has no errors, and is empty.
+ */
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty);
+ATF_TEST_CASE_BODY(nvlist_create__is_empty)
+{
+	nvlist_t *nvl;
+	int type;
+	void *it;
+
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+
+	ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	it = NULL;
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_null__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	int type;
+
+	key = "key";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_null(nvl, key);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_null(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_null(nvl, "key"));
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	int type;
+
+	key = "name";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_bool(nvl, key, true);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me"));
+	ATF_REQUIRE(nvlist_exists_bool(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e'));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true);
+	ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_number__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	uint64_t value;
+	int type;
+
+	key = "foo123";
+	value = 71965;
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_number(nvl, key, value);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123));
+	ATF_REQUIRE(nvlist_exists_number(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key));
+	ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value);
+	ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_string__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	const char *value;
+	int type;
+
+	key = "test";
+	value = "fgjdkgjdk";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_string(nvl, key, value);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_string(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0);
+	ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0);
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(nvlist_get_string(nvl, key) != value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key, *subkey;
+	nvlist_t *sublist;
+	const nvlist_t *value;
+	int type;
+
+	key = "test";
+	subkey = "subkey";
+	sublist = nvlist_create(0);
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_null(sublist, subkey);
+	nvlist_add_nvlist(nvl, key, sublist);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key));
+
+	value = nvlist_get_nvlist(nvl, key);
+	ATF_REQUIRE(nvlist_exists_null(value, subkey));
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(sublist != value);
+
+	value = nvlist_getf_nvlist(nvl, "%s", key);
+	ATF_REQUIRE(nvlist_exists_null(value, subkey));
+	ATF_REQUIRE(sublist != value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(sublist);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	void *value;
+	const void *ret_value;
+	size_t value_size, ret_size;
+	int type;
+
+	key = "binary";
+	value_size = 13;
+	value = malloc(value_size);
+	memset(value, 0xa5, value_size);
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_binary(nvl, key, value, value_size);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_binary(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key));
+
+	ret_value = nvlist_get_binary(nvl, key, &ret_size);
+	ATF_REQUIRE_EQ(value_size, ret_size);
+	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(value != ret_value);
+
+	ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key);
+	ATF_REQUIRE_EQ(value_size, ret_size);
+	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
+	ATF_REQUIRE(value != ret_value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+	free(value);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__empty_nvlist);
+ATF_TEST_CASE_BODY(nvlist_clone__empty_nvlist)
+{
+	nvlist_t *nvl, *clone;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	clone = nvlist_clone(nvl);
+	ATF_REQUIRE(clone != NULL);
+	ATF_REQUIRE(clone != nvl);
+	ATF_REQUIRE(nvlist_empty(clone));
+
+	nvlist_destroy(clone);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nonempty_nvlist);
+ATF_TEST_CASE_BODY(nvlist_clone__nonempty_nvlist)
+{
+	nvlist_t *nvl, *clone;
+	const char *key;
+	void *it;
+	uint64_t value;
+	int type;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	key = "testkey";
+	value = 684874;
+	nvlist_add_number(nvl, key, value);
+
+	clone = nvlist_clone(nvl);
+	ATF_REQUIRE(clone != NULL);
+	ATF_REQUIRE(clone != nvl);
+	ATF_REQUIRE(nvlist_exists_number(clone, key));
+	ATF_REQUIRE_EQ(nvlist_get_number(clone, key), value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(clone, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
+	ATF_REQUIRE_EQ(nvlist_next(clone, &type, &it), NULL);
+
+	nvlist_destroy(clone);
+	nvlist_destroy(nvl);
+}
+
+static const char * const test_subnvlist_key = "nvlist";
+
+static const char * const test_string_key = "string";
+static const char * const test_string_val = "59525";
+
+static nvlist_t*
+create_test_nvlist(void)
+{
+	nvlist_t *nvl, *sublist;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	sublist = nvlist_create(0);
+	ATF_REQUIRE(sublist != NULL);
+
+	nvlist_add_string(sublist, test_string_key, test_string_val);
+	nvlist_move_nvlist(nvl, test_subnvlist_key, sublist);
+
+	return (nvl);
+}
+
+static void
+verify_test_nvlist(const nvlist_t *nvl)
+{
+	void *it;
+	const nvlist_t *value;
+	int type;
+
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, test_subnvlist_key));
+
+	value = nvlist_get_nvlist(nvl, test_subnvlist_key);
+
+	ATF_REQUIRE(nvlist_exists_string(value, test_string_key));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(value, test_string_key), test_string_val), 0);
+	ATF_REQUIRE(nvlist_get_string(value, test_string_key) != test_string_val);
+
+	/* Iterate over both nvlists; ensure that each has only the one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(value, &type, &it),
+	    test_string_key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
+	ATF_REQUIRE_EQ(nvlist_next(value, &type, &it), NULL);
+
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it),
+	    test_subnvlist_key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nested_nvlist);
+ATF_TEST_CASE_BODY(nvlist_clone__nested_nvlist)
+{
+	nvlist_t *nvl, *clone;
+
+	nvl = create_test_nvlist();
+	clone = nvlist_clone(nvl);
+
+	ATF_REQUIRE(clone != NULL);
+	ATF_REQUIRE(clone != nvl);
+	verify_test_nvlist(clone);
+
+	nvlist_destroy(clone);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__empty_nvlist);
+ATF_TEST_CASE_BODY(nvlist_pack__empty_nvlist)
+{
+	nvlist_t *nvl, *unpacked;
+	void *packed;
+	size_t packed_size;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	packed = nvlist_pack(nvl, &packed_size);
+	ATF_REQUIRE(packed != NULL);
+
+	unpacked = nvlist_unpack(packed, packed_size);
+	ATF_REQUIRE(unpacked != NULL);
+	ATF_REQUIRE(unpacked != nvl);
+	ATF_REQUIRE(nvlist_empty(unpacked));
+
+	nvlist_destroy(unpacked);
+	nvlist_destroy(nvl);
+	free(packed);
+}
+
+static void
+verify_null(const nvlist_t *nvl, int type)
+{
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
+}
+
+static void
+verify_number(const nvlist_t *nvl, const char *name, int type, uint64_t value)
+{
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
+	ATF_REQUIRE_EQ(nvlist_get_number(nvl, name), value);
+}
+
+static void
+verify_string(const nvlist_t *nvl, const char *name, int type,
+    const char * value)
+{
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, name), value), 0);
+}
+
+static void
+verify_nvlist(const nvlist_t *nvl, const char *name, int type)
+{
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
+	verify_test_nvlist(nvlist_get_nvlist(nvl, name));
+}
+
+static void
+verify_binary(const nvlist_t *nvl, const char *name, int type,
+    const void * value, size_t size)
+{
+	const void *actual_value;
+	size_t actual_size;
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
+	actual_value = nvlist_get_binary(nvl, name, &actual_size);
+	ATF_REQUIRE_EQ(size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(value, actual_value, size), 0);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__multiple_values);
+ATF_TEST_CASE_BODY(nvlist_pack__multiple_values)
+{
+	std::ostringstream msg;
+	std::set<std::string> keys_seen;
+	nvlist_t *nvl, *unpacked, *nvvalue;
+	const char *nullkey, *numkey, *strkey, *nvkey, *binkey, *name;
+	int numvalue;
+	const char * strvalue;
+	void *binvalue, *packed, *it;
+	size_t binsize, packed_size;
+	int type;
+
+	nvl = nvlist_create(0);
+
+	nullkey = "null";
+	nvlist_add_null(nvl, nullkey);
+
+	numkey = "number";
+	numvalue = 939853984;
+	nvlist_add_number(nvl, numkey, numvalue);
+
+	strkey = "string";
+	strvalue = "jfieutijf";
+	nvlist_add_string(nvl, strkey, strvalue);
+
+	nvkey = "nvlist";
+	nvvalue = create_test_nvlist();
+	nvlist_move_nvlist(nvl, nvkey, nvvalue);
+
+	binkey = "binary";
+	binsize = 4;
+	binvalue = malloc(binsize);
+	memset(binvalue, 'b', binsize);
+	nvlist_move_binary(nvl, binkey, binvalue, binsize);
+
+	packed = nvlist_pack(nvl, &packed_size);
+	ATF_REQUIRE(packed != NULL);
+
+	unpacked = nvlist_unpack(packed, packed_size);
+	ATF_REQUIRE(unpacked != 0);
+
+	it = NULL;
+	while ((name = nvlist_next(unpacked, &type, &it)) != NULL) {
+		/* Ensure that we see every key only once. */
+		ATF_REQUIRE_EQ(keys_seen.count(name), 0);
+
+		if (strcmp(name, nullkey) == 0)
+			verify_null(unpacked, type);
+		else if (strcmp(name, numkey) == 0)
+			verify_number(unpacked, name, type, numvalue);
+		else if (strcmp(name, strkey) == 0)
+			verify_string(unpacked, name, type, strvalue);
+		else if (strcmp(name, nvkey) == 0)
+			verify_nvlist(unpacked, name, type);
+		else if (strcmp(name, binkey) == 0)
+			verify_binary(unpacked, name, type, binvalue, binsize);
+		else {
+			msg << "Unexpected key :'" << name << "'";
+			ATF_FAIL(msg.str().c_str());
+		}
+
+		keys_seen.insert(name);
+	}
+
+	/* Ensure that we saw every key. */
+	ATF_REQUIRE_EQ(keys_seen.size(), 5);
+
+	nvlist_destroy(nvl);
+	nvlist_destroy(unpacked);
+	free(packed);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__duplicate_key);
+ATF_TEST_CASE_BODY(nvlist_unpack__duplicate_key)
+{
+	nvlist_t *nvl, *unpacked;
+	const char *key1, *key2;
+	void *packed, *keypos;
+	size_t size, keylen;
+
+	nvl = nvlist_create(0);
+
+	key1 = "key1";
+	keylen = strlen(key1);
+	nvlist_add_number(nvl, key1, 5);
+
+	key2 = "key2";
+	ATF_REQUIRE_EQ(keylen, strlen(key2));
+	nvlist_add_number(nvl, key2, 10);
+
+	packed = nvlist_pack(nvl, &size);
+
+	/*
+	 * Mangle the packed nvlist by replacing key1 with key2, creating a
+	 * packed nvlist with a duplicate key.
+	 */
+	keypos = memmem(packed, size, key1, keylen);
+	ATF_REQUIRE(keypos != NULL);
+	memcpy(keypos, key2, keylen);
+
+	unpacked = nvlist_unpack(packed, size);
+	ATF_REQUIRE(nvlist_error(unpacked) != 0);
+
+	free(packed);
+	nvlist_destroy(nvl);
+	nvlist_destroy(unpacked);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_string__single_insert);
+ATF_TEST_CASE_BODY(nvlist_move_string__single_insert)
+{
+	nvlist_t *nvl;
+	const char *key;
+	char *value;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	key = "testkey";
+	value = strdup("testval");
+	ATF_REQUIRE(value != NULL);
+
+	nvlist_move_string(nvl, key, value);
+	ATF_REQUIRE_EQ(nvlist_get_string(nvl, key), value);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__null_child);
+ATF_TEST_CASE_BODY(nvlist_move_nvlist__null_child)
+{
+	nvlist_t *parent;
+
+	parent = nvlist_create(0);
+
+	nvlist_move_nvlist(parent, "test", NULL);
+
+	ATF_REQUIRE(nvlist_error(parent) != 0);
+
+	nvlist_destroy(parent);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__single_insert);
+ATF_TEST_CASE_BODY(nvlist_move_nvlist__single_insert)
+{
+	nvlist_t *nvl;
+	const char *key;
+	nvlist_t *value;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	key = "testkey";
+	value = nvlist_create(0);
+	ATF_REQUIRE(value != NULL);
+
+	nvlist_move_nvlist(nvl, key, value);
+	ATF_REQUIRE_EQ(nvlist_get_nvlist(nvl, key), value);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_binary__single_insert);
+ATF_TEST_CASE_BODY(nvlist_move_binary__single_insert)
+{
+	nvlist_t *nvl;
+	const char *key;
+	void *value;
+	size_t size, actual_size;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	key = "testkey";
+	size = 73;
+	value = malloc(size);
+	ATF_REQUIRE(value != NULL);
+
+	nvlist_move_binary(nvl, key, value, size);
+	ATF_REQUIRE_EQ(nvlist_get_binary(nvl, key, &actual_size), value);
+	ATF_REQUIRE_EQ(size, actual_size);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_bool__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	bool testval;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "boolkey";
+	testval = false;
+	nvlist_add_bool(nvl, testkey, testval);
+
+	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_bool__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	bool testval, otherval1;
+	nvlist_t *otherval2;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "boolkey";
+	testval = true;
+	nvlist_add_bool(nvl, testkey, testval);
+
+	otherkey1 = "key1";
+	otherval1 = false;
+	nvlist_add_bool(nvl, otherkey1, otherval1);
+
+	otherkey2 = "key2";
+	otherval2 = create_test_nvlist();
+	nvlist_move_nvlist(nvl, otherkey2, otherval2);
+
+	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
+
+	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey1));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey1), otherval1);
+
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey2));
+	verify_test_nvlist(nvlist_get_nvlist(nvl, otherkey2));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_number__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	uint64_t testval;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "numkey";
+	testval = std::numeric_limits<uint64_t>::max();
+	nvlist_add_number(nvl, testkey, testval);
+
+	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_number__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	uint64_t testval, otherval1;
+	const char *otherval2;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	otherkey1 = "key1";
+	otherval1 = 5;
+	nvlist_add_number(nvl, otherkey1, otherval1);
+
+	testkey = "numkey";
+	testval = 1654;
+	nvlist_add_number(nvl, testkey, testval);
+
+	otherkey2 = "key2";
+	otherval2 = "string";
+	nvlist_add_string(nvl, otherkey2, otherval2);
+
+	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
+
+	ATF_REQUIRE(nvlist_exists_number(nvl, otherkey1));
+	ATF_REQUIRE_EQ(nvlist_get_number(nvl, otherkey1), otherval1);
+
+	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey2));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey2), otherval2), 0);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_string__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	const char *testval;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "numkey";
+	testval = "nvlist";
+	nvlist_add_string(nvl, testkey, testval);
+
+	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_string__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	const char *testval, *otherval1;
+	bool otherval2;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	otherkey1 = "key1";
+	otherval1 = "fjdifjdk";
+	nvlist_add_string(nvl, otherkey1, otherval1);
+
+	otherkey2 = "key2";
+	otherval2 = true;
+	nvlist_add_bool(nvl, otherkey2, otherval2);
+
+	testkey = "strkey";
+	testval = "1654";
+	nvlist_add_string(nvl, testkey, testval);
+
+	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
+
+	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey1));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey1), otherval1), 0);
+
+	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_nvlist__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	nvlist_t *testval;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "numkey";
+	testval = create_test_nvlist();
+	nvlist_move_nvlist(nvl, testkey, testval);
+
+	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_nvlist__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	nvlist_t *testval, *otherval1;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "strkey";
+	testval = create_test_nvlist();
+	nvlist_move_nvlist(nvl, testkey, testval);
+
+	otherkey1 = "key1";
+	otherval1 = nvlist_create(0);
+	nvlist_move_nvlist(nvl, otherkey1, otherval1);
+
+	otherkey2 = "key2";
+	nvlist_add_null(nvl, otherkey2);
+
+	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
+
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey1));
+	ATF_REQUIRE(nvlist_empty(nvlist_get_nvlist(nvl, otherkey1)));
+
+	ATF_REQUIRE(nvlist_exists_null(nvl, otherkey2));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_binary__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	void *testval;
+	const void *actual_val;
+	size_t testsize, actual_size;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "numkey";
+	testsize = 457;
+	testval = malloc(testsize);
+	memset(testval, '5', testsize);
+	nvlist_move_binary(nvl, testkey, testval, testsize);
+
+	actual_val = nvlist_take_binary(nvl, testkey, &actual_size);
+	ATF_REQUIRE_EQ(testsize, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_val, testval, testsize), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_binary__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	const void *actual_value;
+	char testval[] = "gjiertj";
+	char otherval1[] = "fdreg";
+	size_t testsize, othersize, actual_size;
+	bool otherval2;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	otherkey1 = "key1";
+	othersize = sizeof(otherval1);
+	nvlist_add_binary(nvl, otherkey1, otherval1, othersize);
+
+	otherkey2 = "key2";
+	otherval2 = true;
+	nvlist_add_bool(nvl, otherkey2, otherval2);
+
+	testkey = "strkey";
+	testsize = sizeof(testval);
+	nvlist_add_binary(nvl, testkey, testval, testsize);
+
+	actual_value = nvlist_take_binary(nvl, testkey, &actual_size);
+	ATF_REQUIRE_EQ(testsize, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, testval, testsize), 0);
+
+	ATF_REQUIRE(nvlist_exists_binary(nvl, otherkey1));
+	actual_value = nvlist_get_binary(nvl, otherkey1, &actual_size);
+	ATF_REQUIRE_EQ(othersize, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, otherval1, othersize), 0);
+
+	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_null);
+ATF_TEST_CASE_BODY(nvlist_free__single_null)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_null(nvl, key);
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_bool);
+ATF_TEST_CASE_BODY(nvlist_free__single_bool)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_bool(nvl, key, true);
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_number);
+ATF_TEST_CASE_BODY(nvlist_free__single_number)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_number(nvl, key, 584);
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_string);
+ATF_TEST_CASE_BODY(nvlist_free__single_string)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_string(nvl, key, "gjkfkjd");
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_nvlist);
+ATF_TEST_CASE_BODY(nvlist_free__single_nvlist)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_nvlist(nvl, key, nvlist_create(0));
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_binary);
+ATF_TEST_CASE_BODY(nvlist_free__single_binary)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_binary(nvl, key, "jgjgfd", 6);
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_null__single_null);
+ATF_TEST_CASE_BODY(nvlist_free_null__single_null)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_null(nvl, key);
+
+	nvlist_free_null(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_bool__single_bool);
+ATF_TEST_CASE_BODY(nvlist_free_bool__single_bool)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_bool(nvl, key, true);
+
+	nvlist_free_bool(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_number__single_number);
+ATF_TEST_CASE_BODY(nvlist_free_number__single_number)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_number(nvl, key, 584);
+
+	nvlist_free_number(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_string__single_string);
+ATF_TEST_CASE_BODY(nvlist_free_string__single_string)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_string(nvl, key, "gjkfkjd");
+
+	nvlist_free_string(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_nvlist__single_nvlist);
+ATF_TEST_CASE_BODY(nvlist_free_nvlist__single_nvlist)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_nvlist(nvl, key, nvlist_create(0));
+
+	nvlist_free_nvlist(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_binary__single_binary);
+ATF_TEST_CASE_BODY(nvlist_free_binary__single_binary)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_binary(nvl, key, "jgjgfd", 6);
+
+	nvlist_free_binary(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_INIT_TEST_CASES(tp)
+{
+	ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_clone__empty_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_clone__nonempty_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_clone__nested_nvlist);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_pack__empty_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_pack__multiple_values);
+	ATF_ADD_TEST_CASE(tp, nvlist_unpack__duplicate_key);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_move_string__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__null_child);
+	ATF_ADD_TEST_CASE(tp, nvlist_move_binary__single_insert);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__other_keys_unchanged);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_number__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_number__other_keys_unchanged);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_string__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_string__other_keys_unchanged);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__other_keys_unchanged);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__other_keys_unchanged);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_null);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_bool);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_number);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_string);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_binary);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_free_null__single_null);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_bool__single_bool);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_number__single_number);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_string__single_string);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_nvlist__single_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_binary__single_binary);
+}
+/*-
+ * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <atf-c++.hpp>
+#include <nv.h>
+
+#include <errno.h>
+/*
+ * Test that a newly created nvlist has no errors, and is empty.
+ */
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty);
+ATF_TEST_CASE_BODY(nvlist_create__is_empty)
+{
+	nvlist_t *nvl;
+	int type;
+	void *it;
+
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+
+	ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	it = NULL;
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_null__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	int type;
+
+	key = "key";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_null(nvl, key);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_null(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_null(nvl, "key"));
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	int type;
+
+	key = "name";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_bool(nvl, key, true);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me"));
+	ATF_REQUIRE(nvlist_exists_bool(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e'));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true);
+	ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_number__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	uint64_t value;
+	int type;
+
+	key = "foo123";
+	value = 71965;
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_number(nvl, key, value);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123));
+	ATF_REQUIRE(nvlist_exists_number(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key));
+	ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value);
+	ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_string__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	const char *value;
+	int type;
+
+	key = "test";
+	value = "fgjdkgjdk";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_string(nvl, key, value);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_string(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0);
+	ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0);
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(nvlist_get_string(nvl, key) != value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key, *subkey;
+	nvlist_t *sublist;
+	const nvlist_t *value;
+	int type;
+
+	key = "test";
+	subkey = "subkey";
+	sublist = nvlist_create(0);
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_null(sublist, subkey);
+	nvlist_add_nvlist(nvl, key, sublist);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key));
+
+	value = nvlist_get_nvlist(nvl, key);
+	ATF_REQUIRE(nvlist_exists_null(value, subkey));
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(sublist != value);
+
+	value = nvlist_getf_nvlist(nvl, "%s", key);
+	ATF_REQUIRE(nvlist_exists_null(value, subkey));
+	ATF_REQUIRE(sublist != value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(sublist);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	void *value;
+	const void *ret_value;
+	size_t value_size, ret_size;
+	int type;
+
+	key = "binary";
+	value_size = 13;
+	value = malloc(value_size);
+	memset(value, 0xa5, value_size);
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_binary(nvl, key, value, value_size);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_binary(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key));
+
+	ret_value = nvlist_get_binary(nvl, key, &ret_size);
+	ATF_REQUIRE_EQ(value_size, ret_size);
+	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(value != ret_value);
+
+	ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key);
+	ATF_REQUIRE_EQ(value_size, ret_size);
+	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
+	ATF_REQUIRE(value != ret_value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+	free(value);
+}
+
+ATF_INIT_TEST_CASES(tp)
+{
+	ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert);
+}
+/*-
+ * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <atf-c++.hpp>
+#include <nv.h>
+
+#include <errno.h>
+/*
+ * Test that a newly created nvlist has no errors, and is empty.
+ */
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty);
+ATF_TEST_CASE_BODY(nvlist_create__is_empty)
+{
+	nvlist_t *nvl;
+	int type;
+	void *it;
+
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+
+	ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	it = NULL;
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_null__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	int type;
+
+	key = "key";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_null(nvl, key);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_null(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_null(nvl, "key"));
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	int type;
+
+	key = "name";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_bool(nvl, key, true);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me"));
+	ATF_REQUIRE(nvlist_exists_bool(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e'));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true);
+	ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_number__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	uint64_t value;
+	int type;
+
+	key = "foo123";
+	value = 71965;
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_number(nvl, key, value);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123));
+	ATF_REQUIRE(nvlist_exists_number(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key));
+	ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value);
+	ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_string__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	const char *value;
+	int type;
+
+	key = "test";
+	value = "fgjdkgjdk";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_string(nvl, key, value);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_string(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0);
+	ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0);
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(nvlist_get_string(nvl, key) != value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key, *subkey;
+	nvlist_t *sublist;
+	const nvlist_t *value;
+	int type;
+
+	key = "test";
+	subkey = "subkey";
+	sublist = nvlist_create(0);
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_null(sublist, subkey);
+	nvlist_add_nvlist(nvl, key, sublist);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key));
+
+	value = nvlist_get_nvlist(nvl, key);
+	ATF_REQUIRE(nvlist_exists_null(value, subkey));
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(sublist != value);
+
+	value = nvlist_getf_nvlist(nvl, "%s", key);
+	ATF_REQUIRE(nvlist_exists_null(value, subkey));
+	ATF_REQUIRE(sublist != value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(sublist);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	void *value;
+	const void *ret_value;
+	size_t value_size, ret_size;
+	int type;
+
+	key = "binary";
+	value_size = 13;
+	value = malloc(value_size);
+	memset(value, 0xa5, value_size);
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_binary(nvl, key, value, value_size);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_binary(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key));
+
+	ret_value = nvlist_get_binary(nvl, key, &ret_size);
+	ATF_REQUIRE_EQ(value_size, ret_size);
+	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(value != ret_value);
+
+	ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key);
+	ATF_REQUIRE_EQ(value_size, ret_size);
+	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
+	ATF_REQUIRE(value != ret_value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+	free(value);
+}
+
+ATF_INIT_TEST_CASES(tp)
+{
+	ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert);
+}
+/*-
+ * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <atf-c++.hpp>
+#include <nv.h>
+
+#include <errno.h>
+#include <limits>
+#include <set>
+#include <sstream>
+#include <string>
+
+/*
+ * Test that a newly created nvlist has no errors, and is empty.
+ */
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty);
+ATF_TEST_CASE_BODY(nvlist_create__is_empty)
+{
+	nvlist_t *nvl;
+	int type;
+	void *it;
+
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+
+	ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	it = NULL;
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_null__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	int type;
+
+	key = "key";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_null(nvl, key);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_null(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_null(nvl, "key"));
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	int type;
+
+	key = "name";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_bool(nvl, key, true);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me"));
+	ATF_REQUIRE(nvlist_exists_bool(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e'));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true);
+	ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_number__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	uint64_t value;
+	int type;
+
+	key = "foo123";
+	value = 71965;
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_number(nvl, key, value);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123));
+	ATF_REQUIRE(nvlist_exists_number(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key));
+	ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value);
+	ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_string__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	const char *value;
+	int type;
+
+	key = "test";
+	value = "fgjdkgjdk";
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_string(nvl, key, value);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_string(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0);
+	ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0);
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(nvlist_get_string(nvl, key) != value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key, *subkey;
+	nvlist_t *sublist;
+	const nvlist_t *value;
+	int type;
+
+	key = "test";
+	subkey = "subkey";
+	sublist = nvlist_create(0);
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_null(sublist, subkey);
+	nvlist_add_nvlist(nvl, key, sublist);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key));
+
+	value = nvlist_get_nvlist(nvl, key);
+	ATF_REQUIRE(nvlist_exists_null(value, subkey));
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(sublist != value);
+
+	value = nvlist_getf_nvlist(nvl, "%s", key);
+	ATF_REQUIRE(nvlist_exists_null(value, subkey));
+	ATF_REQUIRE(sublist != value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(sublist);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert);
+ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert)
+{
+	nvlist_t *nvl;
+	void *it;
+	const char *key;
+	void *value;
+	const void *ret_value;
+	size_t value_size, ret_size;
+	int type;
+
+	key = "binary";
+	value_size = 13;
+	value = malloc(value_size);
+	memset(value, 0xa5, value_size);
+	nvl = nvlist_create(0);
+
+	ATF_REQUIRE(nvl != NULL);
+	ATF_REQUIRE(!nvlist_exists(nvl, key));
+
+	nvlist_add_binary(nvl, key, value, value_size);
+
+	ATF_REQUIRE(!nvlist_empty(nvl));
+	ATF_REQUIRE(nvlist_exists(nvl, key));
+	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
+	ATF_REQUIRE(nvlist_exists_binary(nvl, key));
+	ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key));
+
+	ret_value = nvlist_get_binary(nvl, key, &ret_size);
+	ATF_REQUIRE_EQ(value_size, ret_size);
+	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
+
+	/* nvlist_add_* is required to clone the value, so check for that. */
+	ATF_REQUIRE(value != ret_value);
+
+	ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key);
+	ATF_REQUIRE_EQ(value_size, ret_size);
+	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
+	ATF_REQUIRE(value != ret_value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
+
+	nvlist_destroy(nvl);
+	free(value);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__empty_nvlist);
+ATF_TEST_CASE_BODY(nvlist_clone__empty_nvlist)
+{
+	nvlist_t *nvl, *clone;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	clone = nvlist_clone(nvl);
+	ATF_REQUIRE(clone != NULL);
+	ATF_REQUIRE(clone != nvl);
+	ATF_REQUIRE(nvlist_empty(clone));
+
+	nvlist_destroy(clone);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nonempty_nvlist);
+ATF_TEST_CASE_BODY(nvlist_clone__nonempty_nvlist)
+{
+	nvlist_t *nvl, *clone;
+	const char *key;
+	void *it;
+	uint64_t value;
+	int type;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	key = "testkey";
+	value = 684874;
+	nvlist_add_number(nvl, key, value);
+
+	clone = nvlist_clone(nvl);
+	ATF_REQUIRE(clone != NULL);
+	ATF_REQUIRE(clone != nvl);
+	ATF_REQUIRE(nvlist_exists_number(clone, key));
+	ATF_REQUIRE_EQ(nvlist_get_number(clone, key), value);
+
+	/* Iterate over the nvlist; ensure that it has only our one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(clone, &type, &it), key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
+	ATF_REQUIRE_EQ(nvlist_next(clone, &type, &it), NULL);
+
+	nvlist_destroy(clone);
+	nvlist_destroy(nvl);
+}
+
+static const char * const test_subnvlist_key = "nvlist";
+
+static const char * const test_string_key = "string";
+static const char * const test_string_val = "59525";
+
+static nvlist_t*
+create_test_nvlist(void)
+{
+	nvlist_t *nvl, *sublist;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	sublist = nvlist_create(0);
+	ATF_REQUIRE(sublist != NULL);
+
+	nvlist_add_string(sublist, test_string_key, test_string_val);
+	nvlist_move_nvlist(nvl, test_subnvlist_key, sublist);
+
+	return (nvl);
+}
+
+static void
+verify_test_nvlist(const nvlist_t *nvl)
+{
+	void *it;
+	const nvlist_t *value;
+	int type;
+
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, test_subnvlist_key));
+
+	value = nvlist_get_nvlist(nvl, test_subnvlist_key);
+
+	ATF_REQUIRE(nvlist_exists_string(value, test_string_key));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(value, test_string_key), test_string_val), 0);
+	ATF_REQUIRE(nvlist_get_string(value, test_string_key) != test_string_val);
+
+	/* Iterate over both nvlists; ensure that each has only the one key. */
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(value, &type, &it),
+	    test_string_key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
+	ATF_REQUIRE_EQ(nvlist_next(value, &type, &it), NULL);
+
+	it = NULL;
+	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it),
+	    test_subnvlist_key), 0);
+	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
+	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nested_nvlist);
+ATF_TEST_CASE_BODY(nvlist_clone__nested_nvlist)
+{
+	nvlist_t *nvl, *clone;
+
+	nvl = create_test_nvlist();
+	clone = nvlist_clone(nvl);
+
+	ATF_REQUIRE(clone != NULL);
+	ATF_REQUIRE(clone != nvl);
+	verify_test_nvlist(clone);
+
+	nvlist_destroy(clone);
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__empty_nvlist);
+ATF_TEST_CASE_BODY(nvlist_pack__empty_nvlist)
+{
+	nvlist_t *nvl, *unpacked;
+	void *packed;
+	size_t packed_size;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	packed = nvlist_pack(nvl, &packed_size);
+	ATF_REQUIRE(packed != NULL);
+
+	unpacked = nvlist_unpack(packed, packed_size);
+	ATF_REQUIRE(unpacked != NULL);
+	ATF_REQUIRE(unpacked != nvl);
+	ATF_REQUIRE(nvlist_empty(unpacked));
+
+	nvlist_destroy(unpacked);
+	nvlist_destroy(nvl);
+	free(packed);
+}
+
+static void
+verify_null(const nvlist_t *nvl, int type)
+{
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
+}
+
+static void
+verify_number(const nvlist_t *nvl, const char *name, int type, uint64_t value)
+{
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
+	ATF_REQUIRE_EQ(nvlist_get_number(nvl, name), value);
+}
+
+static void
+verify_string(const nvlist_t *nvl, const char *name, int type,
+    const char * value)
+{
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, name), value), 0);
+}
+
+static void
+verify_nvlist(const nvlist_t *nvl, const char *name, int type)
+{
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
+	verify_test_nvlist(nvlist_get_nvlist(nvl, name));
+}
+
+static void
+verify_binary(const nvlist_t *nvl, const char *name, int type,
+    const void * value, size_t size)
+{
+	const void *actual_value;
+	size_t actual_size;
+
+	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
+	actual_value = nvlist_get_binary(nvl, name, &actual_size);
+	ATF_REQUIRE_EQ(size, actual_size);
+	ATF_REQUIRE_EQ(memcmp(value, actual_value, size), 0);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__multiple_values);
+ATF_TEST_CASE_BODY(nvlist_pack__multiple_values)
+{
+	std::ostringstream msg;
+	std::set<std::string> keys_seen;
+	nvlist_t *nvl, *unpacked, *nvvalue;
+	const char *nullkey, *numkey, *strkey, *nvkey, *binkey, *name;
+	int numvalue;
+	const char * strvalue;
+	void *binvalue, *packed, *it;
+	size_t binsize, packed_size;
+	int type;
+
+	nvl = nvlist_create(0);
+
+	nullkey = "null";
+	nvlist_add_null(nvl, nullkey);
+
+	numkey = "number";
+	numvalue = 939853984;
+	nvlist_add_number(nvl, numkey, numvalue);
+
+	strkey = "string";
+	strvalue = "jfieutijf";
+	nvlist_add_string(nvl, strkey, strvalue);
+
+	nvkey = "nvlist";
+	nvvalue = create_test_nvlist();
+	nvlist_move_nvlist(nvl, nvkey, nvvalue);
+
+	binkey = "binary";
+	binsize = 4;
+	binvalue = malloc(binsize);
+	memset(binvalue, 'b', binsize);
+	nvlist_move_binary(nvl, binkey, binvalue, binsize);
+
+	packed = nvlist_pack(nvl, &packed_size);
+	ATF_REQUIRE(packed != NULL);
+
+	unpacked = nvlist_unpack(packed, packed_size);
+	ATF_REQUIRE(unpacked != 0);
+
+	it = NULL;
+	while ((name = nvlist_next(unpacked, &type, &it)) != NULL) {
+		/* Ensure that we see every key only once. */
+		ATF_REQUIRE_EQ(keys_seen.count(name), 0);
+
+		if (strcmp(name, nullkey) == 0)
+			verify_null(unpacked, type);
+		else if (strcmp(name, numkey) == 0)
+			verify_number(unpacked, name, type, numvalue);
+		else if (strcmp(name, strkey) == 0)
+			verify_string(unpacked, name, type, strvalue);
+		else if (strcmp(name, nvkey) == 0)
+			verify_nvlist(unpacked, name, type);
+		else if (strcmp(name, binkey) == 0)
+			verify_binary(unpacked, name, type, binvalue, binsize);
+		else {
+			msg << "Unexpected key :'" << name << "'";
+			ATF_FAIL(msg.str().c_str());
+		}
+
+		keys_seen.insert(name);
+	}
+
+	/* Ensure that we saw every key. */
+	ATF_REQUIRE_EQ(keys_seen.size(), 5);
+
+	nvlist_destroy(nvl);
+	nvlist_destroy(unpacked);
+	free(packed);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__duplicate_key);
+ATF_TEST_CASE_BODY(nvlist_unpack__duplicate_key)
+{
+	nvlist_t *nvl, *unpacked;
+	const char *key1, *key2;
+	void *packed, *keypos;
+	size_t size, keylen;
+
+	nvl = nvlist_create(0);
+
+	key1 = "key1";
+	keylen = strlen(key1);
+	nvlist_add_number(nvl, key1, 5);
+
+	key2 = "key2";
+	ATF_REQUIRE_EQ(keylen, strlen(key2));
+	nvlist_add_number(nvl, key2, 10);
+
+	packed = nvlist_pack(nvl, &size);
+
+	/*
+	 * Mangle the packed nvlist by replacing key1 with key2, creating a
+	 * packed nvlist with a duplicate key.
+	 */
+	keypos = memmem(packed, size, key1, keylen);
+	ATF_REQUIRE(keypos != NULL);
+	memcpy(keypos, key2, keylen);
+
+	unpacked = nvlist_unpack(packed, size);
+	ATF_REQUIRE(nvlist_error(unpacked) != 0);
+
+	free(packed);
+	nvlist_destroy(nvl);
+	nvlist_destroy(unpacked);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_string__single_insert);
+ATF_TEST_CASE_BODY(nvlist_move_string__single_insert)
+{
+	nvlist_t *nvl;
+	const char *key;
+	char *value;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	key = "testkey";
+	value = strdup("testval");
+	ATF_REQUIRE(value != NULL);
+
+	nvlist_move_string(nvl, key, value);
+	ATF_REQUIRE_EQ(nvlist_get_string(nvl, key), value);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__null_child);
+ATF_TEST_CASE_BODY(nvlist_move_nvlist__null_child)
+{
+	nvlist_t *parent;
+
+	parent = nvlist_create(0);
+
+	nvlist_move_nvlist(parent, "test", NULL);
+
+	ATF_REQUIRE(nvlist_error(parent) != 0);
+
+	nvlist_destroy(parent);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__single_insert);
+ATF_TEST_CASE_BODY(nvlist_move_nvlist__single_insert)
+{
+	nvlist_t *nvl;
+	const char *key;
+	nvlist_t *value;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	key = "testkey";
+	value = nvlist_create(0);
+	ATF_REQUIRE(value != NULL);
+
+	nvlist_move_nvlist(nvl, key, value);
+	ATF_REQUIRE_EQ(nvlist_get_nvlist(nvl, key), value);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_binary__single_insert);
+ATF_TEST_CASE_BODY(nvlist_move_binary__single_insert)
+{
+	nvlist_t *nvl;
+	const char *key;
+	void *value;
+	size_t size, actual_size;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	key = "testkey";
+	size = 73;
+	value = malloc(size);
+	ATF_REQUIRE(value != NULL);
+
+	nvlist_move_binary(nvl, key, value, size);
+	ATF_REQUIRE_EQ(nvlist_get_binary(nvl, key, &actual_size), value);
+	ATF_REQUIRE_EQ(size, actual_size);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_bool__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	bool testval;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "boolkey";
+	testval = false;
+	nvlist_add_bool(nvl, testkey, testval);
+
+	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_bool__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	bool testval, otherval1;
+	nvlist_t *otherval2;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "boolkey";
+	testval = true;
+	nvlist_add_bool(nvl, testkey, testval);
+
+	otherkey1 = "key1";
+	otherval1 = false;
+	nvlist_add_bool(nvl, otherkey1, otherval1);
+
+	otherkey2 = "key2";
+	otherval2 = create_test_nvlist();
+	nvlist_move_nvlist(nvl, otherkey2, otherval2);
+
+	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
+
+	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey1));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey1), otherval1);
+
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey2));
+	verify_test_nvlist(nvlist_get_nvlist(nvl, otherkey2));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_number__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	uint64_t testval;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "numkey";
+	testval = std::numeric_limits<uint64_t>::max();
+	nvlist_add_number(nvl, testkey, testval);
+
+	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_number__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	uint64_t testval, otherval1;
+	const char *otherval2;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	otherkey1 = "key1";
+	otherval1 = 5;
+	nvlist_add_number(nvl, otherkey1, otherval1);
+
+	testkey = "numkey";
+	testval = 1654;
+	nvlist_add_number(nvl, testkey, testval);
+
+	otherkey2 = "key2";
+	otherval2 = "string";
+	nvlist_add_string(nvl, otherkey2, otherval2);
+
+	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
+
+	ATF_REQUIRE(nvlist_exists_number(nvl, otherkey1));
+	ATF_REQUIRE_EQ(nvlist_get_number(nvl, otherkey1), otherval1);
+
+	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey2));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey2), otherval2), 0);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_string__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	const char *testval;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "numkey";
+	testval = "nvlist";
+	nvlist_add_string(nvl, testkey, testval);
+
+	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_string__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	const char *testval, *otherval1;
+	bool otherval2;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	otherkey1 = "key1";
+	otherval1 = "fjdifjdk";
+	nvlist_add_string(nvl, otherkey1, otherval1);
+
+	otherkey2 = "key2";
+	otherval2 = true;
+	nvlist_add_bool(nvl, otherkey2, otherval2);
+
+	testkey = "strkey";
+	testval = "1654";
+	nvlist_add_string(nvl, testkey, testval);
+
+	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
+
+	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey1));
+	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey1), otherval1), 0);
+
+	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_nvlist__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	nvlist_t *testval;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "numkey";
+	testval = create_test_nvlist();
+	nvlist_move_nvlist(nvl, testkey, testval);
+
+	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_nvlist__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	nvlist_t *testval, *otherval1;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "strkey";
+	testval = create_test_nvlist();
+	nvlist_move_nvlist(nvl, testkey, testval);
+
+	otherkey1 = "key1";
+	otherval1 = nvlist_create(0);
+	nvlist_move_nvlist(nvl, otherkey1, otherval1);
+
+	otherkey2 = "key2";
+	nvlist_add_null(nvl, otherkey2);
+
+	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
+
+	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey1));
+	ATF_REQUIRE(nvlist_empty(nvlist_get_nvlist(nvl, otherkey1)));
+
+	ATF_REQUIRE(nvlist_exists_null(nvl, otherkey2));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__single_remove);
+ATF_TEST_CASE_BODY(nvlist_take_binary__single_remove)
+{
+	nvlist_t *nvl;
+	const char *testkey;
+	void *testval;
+	const void *actual_val;
+	size_t testsize, actual_size;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	testkey = "numkey";
+	testsize = 457;
+	testval = malloc(testsize);
+	memset(testval, '5', testsize);
+	nvlist_move_binary(nvl, testkey, testval, testsize);
+
+	actual_val = nvlist_take_binary(nvl, testkey, &actual_size);
+	ATF_REQUIRE_EQ(testsize, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_val, testval, testsize), 0);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__other_keys_unchanged);
+ATF_TEST_CASE_BODY(nvlist_take_binary__other_keys_unchanged)
+{
+	nvlist_t *nvl;
+	const char *testkey, *otherkey1, *otherkey2;
+	const void *actual_value;
+	char testval[] = "gjiertj";
+	char otherval1[] = "fdreg";
+	size_t testsize, othersize, actual_size;
+	bool otherval2;
+
+	nvl = nvlist_create(0);
+	ATF_REQUIRE(nvl != NULL);
+
+	otherkey1 = "key1";
+	othersize = sizeof(otherval1);
+	nvlist_add_binary(nvl, otherkey1, otherval1, othersize);
+
+	otherkey2 = "key2";
+	otherval2 = true;
+	nvlist_add_bool(nvl, otherkey2, otherval2);
+
+	testkey = "strkey";
+	testsize = sizeof(testval);
+	nvlist_add_binary(nvl, testkey, testval, testsize);
+
+	actual_value = nvlist_take_binary(nvl, testkey, &actual_size);
+	ATF_REQUIRE_EQ(testsize, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, testval, testsize), 0);
+
+	ATF_REQUIRE(nvlist_exists_binary(nvl, otherkey1));
+	actual_value = nvlist_get_binary(nvl, otherkey1, &actual_size);
+	ATF_REQUIRE_EQ(othersize, actual_size);
+	ATF_REQUIRE_EQ(memcmp(actual_value, otherval1, othersize), 0);
+
+	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
+	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_null);
+ATF_TEST_CASE_BODY(nvlist_free__single_null)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_null(nvl, key);
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_bool);
+ATF_TEST_CASE_BODY(nvlist_free__single_bool)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_bool(nvl, key, true);
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_number);
+ATF_TEST_CASE_BODY(nvlist_free__single_number)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_number(nvl, key, 584);
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_string);
+ATF_TEST_CASE_BODY(nvlist_free__single_string)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_string(nvl, key, "gjkfkjd");
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_nvlist);
+ATF_TEST_CASE_BODY(nvlist_free__single_nvlist)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_nvlist(nvl, key, nvlist_create(0));
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_binary);
+ATF_TEST_CASE_BODY(nvlist_free__single_binary)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_binary(nvl, key, "jgjgfd", 6);
+
+	nvlist_free(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_null__single_null);
+ATF_TEST_CASE_BODY(nvlist_free_null__single_null)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_null(nvl, key);
+
+	nvlist_free_null(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_bool__single_bool);
+ATF_TEST_CASE_BODY(nvlist_free_bool__single_bool)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_bool(nvl, key, true);
+
+	nvlist_free_bool(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_number__single_number);
+ATF_TEST_CASE_BODY(nvlist_free_number__single_number)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_number(nvl, key, 584);
+
+	nvlist_free_number(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_string__single_string);
+ATF_TEST_CASE_BODY(nvlist_free_string__single_string)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_string(nvl, key, "gjkfkjd");
+
+	nvlist_free_string(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_nvlist__single_nvlist);
+ATF_TEST_CASE_BODY(nvlist_free_nvlist__single_nvlist)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_nvlist(nvl, key, nvlist_create(0));
+
+	nvlist_free_nvlist(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_binary__single_binary);
+ATF_TEST_CASE_BODY(nvlist_free_binary__single_binary)
+{
+	nvlist_t *nvl;
+	const char *key;
+
+	nvl = nvlist_create(0);
+	key = "test";
+	nvlist_add_binary(nvl, key, "jgjgfd", 6);
+
+	nvlist_free_binary(nvl, key);
+	ATF_REQUIRE(nvlist_empty(nvl));
+
+	nvlist_destroy(nvl);
+}
+
+ATF_INIT_TEST_CASES(tp)
+{
+	ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_clone__empty_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_clone__nonempty_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_clone__nested_nvlist);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_pack__empty_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_pack__multiple_values);
+	ATF_ADD_TEST_CASE(tp, nvlist_unpack__duplicate_key);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_move_string__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__single_insert);
+	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__null_child);
+	ATF_ADD_TEST_CASE(tp, nvlist_move_binary__single_insert);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__other_keys_unchanged);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_number__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_number__other_keys_unchanged);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_string__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_string__other_keys_unchanged);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__other_keys_unchanged);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__single_remove);
+	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__other_keys_unchanged);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_null);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_bool);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_number);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_string);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_free__single_binary);
+
+	ATF_ADD_TEST_CASE(tp, nvlist_free_null__single_null);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_bool__single_bool);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_number__single_number);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_string__single_string);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_nvlist__single_nvlist);
+	ATF_ADD_TEST_CASE(tp, nvlist_free_binary__single_binary);
+}

Property changes on: user/ngie/stable-10-libnv/lib/libnv/tests/nv_tests.cc
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: user/ngie/stable-10-libnv/lib/libnv/tests/nvlist_send_recv_test.c
===================================================================
--- user/ngie/stable-10-libnv/lib/libnv/tests/nvlist_send_recv_test.c	(revision 292633)
+++ user/ngie/stable-10-libnv/lib/libnv/tests/nvlist_send_recv_test.c	(revision 292634)
@@ -1,325 +1,342 @@
 /*-
  * Copyright (c) 2013 The FreeBSD Foundation
  * All rights reserved.
  *
  * This software was developed by Pawel Jakub Dawidek under sponsorship from
  * the FreeBSD Foundation.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  * $FreeBSD$
  */
 
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/wait.h>
 
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 
 #include <nv.h>
 
 static int ntest = 1;
 
 #define	CHECK(expr)	do {						\
 	if ((expr))							\
 		printf("ok # %d %s:%u\n", ntest, __FILE__, __LINE__);	\
 	else								\
 		printf("not ok # %d %s:%u\n", ntest, __FILE__, __LINE__);\
 	ntest++;							\
 } while (0)
 
 #define	fd_is_valid(fd)	(fcntl((fd), F_GETFL) != -1 || errno != EBADF)
 
 static void
 child(int sock)
 {
 	nvlist_t *nvl;
+	nvlist_t *empty;
 
 	nvl = nvlist_create(0);
+	empty = nvlist_create(0);
 
 	nvlist_add_bool(nvl, "nvlist/bool/true", true);
 	nvlist_add_bool(nvl, "nvlist/bool/false", false);
 	nvlist_add_number(nvl, "nvlist/number/0", 0);
 	nvlist_add_number(nvl, "nvlist/number/1", 1);
 	nvlist_add_number(nvl, "nvlist/number/-1", -1);
 	nvlist_add_number(nvl, "nvlist/number/UINT64_MAX", UINT64_MAX);
 	nvlist_add_number(nvl, "nvlist/number/INT64_MIN", INT64_MIN);
 	nvlist_add_number(nvl, "nvlist/number/INT64_MAX", INT64_MAX);
 	nvlist_add_string(nvl, "nvlist/string/", "");
 	nvlist_add_string(nvl, "nvlist/string/x", "x");
 	nvlist_add_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz");
 	nvlist_add_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO", STDERR_FILENO);
 	nvlist_add_binary(nvl, "nvlist/binary/x", "x", 1);
 	nvlist_add_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz"));
+	nvlist_move_nvlist(nvl, "nvlist/nvlist/empty", empty);
 	nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl);
 
 	nvlist_send(sock, nvl);
 
 	nvlist_destroy(nvl);
 }
 
 static void
 parent(int sock)
 {
 	nvlist_t *nvl;
-	const nvlist_t *cnvl;
+	const nvlist_t *cnvl, *empty;
 	const char *name, *cname;
 	void *cookie, *ccookie;
 	int type, ctype;
 	size_t size;
 
 	nvl = nvlist_recv(sock);
 	CHECK(nvlist_error(nvl) == 0);
 	if (nvlist_error(nvl) != 0)
 		err(1, "nvlist_recv() failed");
 
 	cookie = NULL;
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_BOOL);
 	CHECK(strcmp(name, "nvlist/bool/true") == 0);
 	CHECK(nvlist_get_bool(nvl, name) == true);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_BOOL);
 	CHECK(strcmp(name, "nvlist/bool/false") == 0);
 	CHECK(nvlist_get_bool(nvl, name) == false);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_NUMBER);
 	CHECK(strcmp(name, "nvlist/number/0") == 0);
 	CHECK(nvlist_get_number(nvl, name) == 0);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_NUMBER);
 	CHECK(strcmp(name, "nvlist/number/1") == 0);
 	CHECK(nvlist_get_number(nvl, name) == 1);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_NUMBER);
 	CHECK(strcmp(name, "nvlist/number/-1") == 0);
 	CHECK((int)nvlist_get_number(nvl, name) == -1);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_NUMBER);
 	CHECK(strcmp(name, "nvlist/number/UINT64_MAX") == 0);
 	CHECK(nvlist_get_number(nvl, name) == UINT64_MAX);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_NUMBER);
 	CHECK(strcmp(name, "nvlist/number/INT64_MIN") == 0);
 	CHECK((int64_t)nvlist_get_number(nvl, name) == INT64_MIN);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_NUMBER);
 	CHECK(strcmp(name, "nvlist/number/INT64_MAX") == 0);
 	CHECK((int64_t)nvlist_get_number(nvl, name) == INT64_MAX);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_STRING);
 	CHECK(strcmp(name, "nvlist/string/") == 0);
 	CHECK(strcmp(nvlist_get_string(nvl, name), "") == 0);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_STRING);
 	CHECK(strcmp(name, "nvlist/string/x") == 0);
 	CHECK(strcmp(nvlist_get_string(nvl, name), "x") == 0);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_STRING);
 	CHECK(strcmp(name, "nvlist/string/abcdefghijklmnopqrstuvwxyz") == 0);
 	CHECK(strcmp(nvlist_get_string(nvl, name), "abcdefghijklmnopqrstuvwxyz") == 0);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_DESCRIPTOR);
 	CHECK(strcmp(name, "nvlist/descriptor/STDERR_FILENO") == 0);
 	CHECK(fd_is_valid(nvlist_get_descriptor(nvl, name)));
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_BINARY);
 	CHECK(strcmp(name, "nvlist/binary/x") == 0);
 	CHECK(memcmp(nvlist_get_binary(nvl, name, NULL), "x", 1) == 0);
 	CHECK(memcmp(nvlist_get_binary(nvl, name, &size), "x", 1) == 0);
 	CHECK(size == 1);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_BINARY);
 	CHECK(strcmp(name, "nvlist/binary/abcdefghijklmnopqrstuvwxyz") == 0);
 	CHECK(memcmp(nvlist_get_binary(nvl, name, NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
 	CHECK(memcmp(nvlist_get_binary(nvl, name, &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
 	CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name != NULL);
 	CHECK(type == NV_TYPE_NVLIST);
+	CHECK(strcmp(name, "nvlist/nvlist/empty") == 0);
+	cnvl = nvlist_get_nvlist(nvl, name);
+	CHECK(nvlist_empty(cnvl));
+
+	name = nvlist_next(nvl, &type, &cookie);
+	CHECK(name != NULL);
+	CHECK(type == NV_TYPE_NVLIST);
 	CHECK(strcmp(name, "nvlist/nvlist") == 0);
 	cnvl = nvlist_get_nvlist(nvl, name);
 
 	ccookie = NULL;
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_BOOL);
 	CHECK(strcmp(cname, "nvlist/bool/true") == 0);
 	CHECK(nvlist_get_bool(cnvl, cname) == true);
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_BOOL);
 	CHECK(strcmp(cname, "nvlist/bool/false") == 0);
 	CHECK(nvlist_get_bool(cnvl, cname) == false);
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_NUMBER);
 	CHECK(strcmp(cname, "nvlist/number/0") == 0);
 	CHECK(nvlist_get_number(cnvl, cname) == 0);
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_NUMBER);
 	CHECK(strcmp(cname, "nvlist/number/1") == 0);
 	CHECK(nvlist_get_number(cnvl, cname) == 1);
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_NUMBER);
 	CHECK(strcmp(cname, "nvlist/number/-1") == 0);
 	CHECK((int)nvlist_get_number(cnvl, cname) == -1);
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_NUMBER);
 	CHECK(strcmp(cname, "nvlist/number/UINT64_MAX") == 0);
 	CHECK(nvlist_get_number(cnvl, cname) == UINT64_MAX);
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_NUMBER);
 	CHECK(strcmp(cname, "nvlist/number/INT64_MIN") == 0);
 	CHECK((int64_t)nvlist_get_number(cnvl, cname) == INT64_MIN);
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_NUMBER);
 	CHECK(strcmp(cname, "nvlist/number/INT64_MAX") == 0);
 	CHECK((int64_t)nvlist_get_number(cnvl, cname) == INT64_MAX);
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_STRING);
 	CHECK(strcmp(cname, "nvlist/string/") == 0);
 	CHECK(strcmp(nvlist_get_string(cnvl, cname), "") == 0);
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_STRING);
 	CHECK(strcmp(cname, "nvlist/string/x") == 0);
 	CHECK(strcmp(nvlist_get_string(cnvl, cname), "x") == 0);
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_STRING);
 	CHECK(strcmp(cname, "nvlist/string/abcdefghijklmnopqrstuvwxyz") == 0);
 	CHECK(strcmp(nvlist_get_string(cnvl, cname), "abcdefghijklmnopqrstuvwxyz") == 0);
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_DESCRIPTOR);
 	CHECK(strcmp(cname, "nvlist/descriptor/STDERR_FILENO") == 0);
 	CHECK(fd_is_valid(nvlist_get_descriptor(cnvl, cname)));
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_BINARY);
 	CHECK(strcmp(cname, "nvlist/binary/x") == 0);
 	CHECK(memcmp(nvlist_get_binary(cnvl, cname, NULL), "x", 1) == 0);
 	CHECK(memcmp(nvlist_get_binary(cnvl, cname, &size), "x", 1) == 0);
 	CHECK(size == 1);
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname != NULL);
 	CHECK(ctype == NV_TYPE_BINARY);
 	CHECK(strcmp(cname, "nvlist/binary/abcdefghijklmnopqrstuvwxyz") == 0);
 	CHECK(memcmp(nvlist_get_binary(cnvl, cname, NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
 	CHECK(memcmp(nvlist_get_binary(cnvl, cname, &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
 	CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
 
 	cname = nvlist_next(cnvl, &ctype, &ccookie);
+	CHECK(cname != NULL);
+	CHECK(ctype == NV_TYPE_NVLIST);
+	CHECK(strcmp(cname, "nvlist/nvlist/empty") == 0);
+	empty = nvlist_get_nvlist(cnvl, cname);
+	CHECK(nvlist_empty(empty));
+
+	cname = nvlist_next(cnvl, &ctype, &ccookie);
 	CHECK(cname == NULL);
 
 	name = nvlist_next(nvl, &type, &cookie);
 	CHECK(name == NULL);
 }
 
 int
 main(void)
 {
 	int status, socks[2];
 	pid_t pid;
 
-	printf("1..126\n");
+	printf("1..134\n");
 	fflush(stdout);
 
 	if (socketpair(PF_UNIX, SOCK_STREAM, 0, socks) < 0)
 		err(1, "socketpair() failed");
 	pid = fork();
 	switch (pid) {
 	case -1:
 		/* Failure. */
 		err(1, "unable to fork");
 	case 0:
 		/* Child. */
 		close(socks[0]);
 		child(socks[1]);
 		return (0);
 	default:
 		/* Parent. */
 		close(socks[1]);
 		parent(socks[0]);
 		break;
 	}
 
 	if (waitpid(pid, &status, 0) < 0)
 		err(1, "waitpid() failed");
 
 	return (0);
 }
Index: user/ngie/stable-10-libnv
===================================================================
--- user/ngie/stable-10-libnv	(revision 292633)
+++ user/ngie/stable-10-libnv	(revision 292634)

Property changes on: user/ngie/stable-10-libnv
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head:r279424-279432