xref: /freebsd/lib/libnv/tests/nv_tests.cc (revision a87e51626778b12f5679780a20e719b947aa103b)
13075c896SRyan Stone /*-
23075c896SRyan Stone  * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
33075c896SRyan Stone  * All rights reserved.
43075c896SRyan Stone  *
53075c896SRyan Stone  * Redistribution and use in source and binary forms, with or without
63075c896SRyan Stone  * modification, are permitted provided that the following conditions
73075c896SRyan Stone  * are met:
83075c896SRyan Stone  * 1. Redistributions of source code must retain the above copyright
93075c896SRyan Stone  *    notice, this list of conditions and the following disclaimer.
103075c896SRyan Stone  * 2. Redistributions in binary form must reproduce the above copyright
113075c896SRyan Stone  *    notice, this list of conditions and the following disclaimer in the
123075c896SRyan Stone  *    documentation and/or other materials provided with the distribution.
133075c896SRyan Stone  *
143075c896SRyan Stone  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
153075c896SRyan Stone  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
163075c896SRyan Stone  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
173075c896SRyan Stone  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
183075c896SRyan Stone  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
193075c896SRyan Stone  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
203075c896SRyan Stone  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
213075c896SRyan Stone  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
223075c896SRyan Stone  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
233075c896SRyan Stone  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
243075c896SRyan Stone  * SUCH DAMAGE.
253075c896SRyan Stone  */
263075c896SRyan Stone 
273075c896SRyan Stone #include <sys/cdefs.h>
283075c896SRyan Stone __FBSDID("$FreeBSD$");
293075c896SRyan Stone 
303075c896SRyan Stone #include <atf-c++.hpp>
313075c896SRyan Stone #include <nv.h>
323075c896SRyan Stone 
333075c896SRyan Stone #include <errno.h>
34fad0a264SRyan Stone #include <limits>
356c721f82SRyan Stone #include <set>
366c721f82SRyan Stone #include <sstream>
376c721f82SRyan Stone #include <string>
386c721f82SRyan Stone 
393075c896SRyan Stone /*
403075c896SRyan Stone  * Test that a newly created nvlist has no errors, and is empty.
413075c896SRyan Stone  */
423075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty);
433075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_create__is_empty)
443075c896SRyan Stone {
453075c896SRyan Stone 	nvlist_t *nvl;
463075c896SRyan Stone 	int type;
473075c896SRyan Stone 	void *it;
483075c896SRyan Stone 
493075c896SRyan Stone 	nvl = nvlist_create(0);
503075c896SRyan Stone 
513075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
523075c896SRyan Stone 
533075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
543075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
553075c896SRyan Stone 
563075c896SRyan Stone 	it = NULL;
573075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL);
583075c896SRyan Stone 
593075c896SRyan Stone 	nvlist_destroy(nvl);
603075c896SRyan Stone }
613075c896SRyan Stone 
623075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert);
633075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_null__single_insert)
643075c896SRyan Stone {
653075c896SRyan Stone 	nvlist_t *nvl;
663075c896SRyan Stone 	void *it;
673075c896SRyan Stone 	const char *key;
683075c896SRyan Stone 	int type;
693075c896SRyan Stone 
703075c896SRyan Stone 	key = "key";
713075c896SRyan Stone 	nvl = nvlist_create(0);
723075c896SRyan Stone 
733075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
743075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
753075c896SRyan Stone 
763075c896SRyan Stone 	nvlist_add_null(nvl, key);
773075c896SRyan Stone 
783075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
793075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
803075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
813075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(nvl, key));
823075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_null(nvl, "key"));
833075c896SRyan Stone 
843075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
853075c896SRyan Stone 	it = NULL;
863075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
873075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
883075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
893075c896SRyan Stone 
903075c896SRyan Stone 	nvlist_destroy(nvl);
913075c896SRyan Stone }
923075c896SRyan Stone 
933075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert);
943075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert)
953075c896SRyan Stone {
963075c896SRyan Stone 	nvlist_t *nvl;
973075c896SRyan Stone 	void *it;
983075c896SRyan Stone 	const char *key;
993075c896SRyan Stone 	int type;
1003075c896SRyan Stone 
1013075c896SRyan Stone 	key = "name";
1023075c896SRyan Stone 	nvl = nvlist_create(0);
1033075c896SRyan Stone 
1043075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
1053075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
1063075c896SRyan Stone 
1073075c896SRyan Stone 	nvlist_add_bool(nvl, key, true);
1083075c896SRyan Stone 
1093075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
1103075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
1113075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me"));
1123075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_bool(nvl, key));
1133075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e'));
1143075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true);
1153075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true);
1163075c896SRyan Stone 
1173075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
1183075c896SRyan Stone 	it = NULL;
1193075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
1203075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
1213075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
1223075c896SRyan Stone 
1233075c896SRyan Stone 	nvlist_destroy(nvl);
1243075c896SRyan Stone }
1253075c896SRyan Stone 
1263075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert);
1273075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_number__single_insert)
1283075c896SRyan Stone {
1293075c896SRyan Stone 	nvlist_t *nvl;
1303075c896SRyan Stone 	void *it;
1313075c896SRyan Stone 	const char *key;
1323075c896SRyan Stone 	uint64_t value;
1333075c896SRyan Stone 	int type;
1343075c896SRyan Stone 
1353075c896SRyan Stone 	key = "foo123";
1363075c896SRyan Stone 	value = 71965;
1373075c896SRyan Stone 	nvl = nvlist_create(0);
1383075c896SRyan Stone 
1393075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
1403075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
1413075c896SRyan Stone 
1423075c896SRyan Stone 	nvlist_add_number(nvl, key, value);
1433075c896SRyan Stone 
1443075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
1453075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
1463075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123));
1473075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_number(nvl, key));
1483075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key));
1493075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value);
1503075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value);
1513075c896SRyan Stone 
1523075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
1533075c896SRyan Stone 	it = NULL;
1543075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
1553075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
1563075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
1573075c896SRyan Stone 
1583075c896SRyan Stone 	nvlist_destroy(nvl);
1593075c896SRyan Stone }
1603075c896SRyan Stone 
1613075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert);
1623075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_string__single_insert)
1633075c896SRyan Stone {
1643075c896SRyan Stone 	nvlist_t *nvl;
1653075c896SRyan Stone 	void *it;
1663075c896SRyan Stone 	const char *key;
1673075c896SRyan Stone 	const char *value;
1683075c896SRyan Stone 	int type;
1693075c896SRyan Stone 
1703075c896SRyan Stone 	key = "test";
1713075c896SRyan Stone 	value = "fgjdkgjdk";
1723075c896SRyan Stone 	nvl = nvlist_create(0);
1733075c896SRyan Stone 
1743075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
1753075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
1763075c896SRyan Stone 
1773075c896SRyan Stone 	nvlist_add_string(nvl, key, value);
1783075c896SRyan Stone 
1793075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
1803075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
1813075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
1823075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_string(nvl, key));
1833075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key));
1843075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0);
1853075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0);
1863075c896SRyan Stone 
1873075c896SRyan Stone 	/* nvlist_add_* is required to clone the value, so check for that. */
1883075c896SRyan Stone 	ATF_REQUIRE(nvlist_get_string(nvl, key) != value);
1893075c896SRyan Stone 
1903075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
1913075c896SRyan Stone 	it = NULL;
1923075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
1933075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
1943075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
1953075c896SRyan Stone 
1963075c896SRyan Stone 	nvlist_destroy(nvl);
1973075c896SRyan Stone }
1983075c896SRyan Stone 
1993075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert);
2003075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert)
2013075c896SRyan Stone {
2023075c896SRyan Stone 	nvlist_t *nvl;
2033075c896SRyan Stone 	void *it;
2043075c896SRyan Stone 	const char *key, *subkey;
2053075c896SRyan Stone 	nvlist_t *sublist;
2063075c896SRyan Stone 	const nvlist_t *value;
2073075c896SRyan Stone 	int type;
2083075c896SRyan Stone 
2093075c896SRyan Stone 	key = "test";
2103075c896SRyan Stone 	subkey = "subkey";
2113075c896SRyan Stone 	sublist = nvlist_create(0);
2123075c896SRyan Stone 	nvl = nvlist_create(0);
2133075c896SRyan Stone 
2143075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
2153075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
2163075c896SRyan Stone 
2173075c896SRyan Stone 	nvlist_add_null(sublist, subkey);
2183075c896SRyan Stone 	nvlist_add_nvlist(nvl, key, sublist);
2193075c896SRyan Stone 
2203075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
2213075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
2223075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
2233075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
2243075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key));
2253075c896SRyan Stone 
2263075c896SRyan Stone 	value = nvlist_get_nvlist(nvl, key);
2273075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(value, subkey));
2283075c896SRyan Stone 
2293075c896SRyan Stone 	/* nvlist_add_* is required to clone the value, so check for that. */
2303075c896SRyan Stone 	ATF_REQUIRE(sublist != value);
2313075c896SRyan Stone 
2323075c896SRyan Stone 	value = nvlist_getf_nvlist(nvl, "%s", key);
2333075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(value, subkey));
2343075c896SRyan Stone 	ATF_REQUIRE(sublist != value);
2353075c896SRyan Stone 
2363075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
2373075c896SRyan Stone 	it = NULL;
2383075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
2393075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
2403075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
2413075c896SRyan Stone 
2423075c896SRyan Stone 	nvlist_destroy(sublist);
2433075c896SRyan Stone 	nvlist_destroy(nvl);
2443075c896SRyan Stone }
2453075c896SRyan Stone 
2463075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert);
2473075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert)
2483075c896SRyan Stone {
2493075c896SRyan Stone 	nvlist_t *nvl;
2503075c896SRyan Stone 	void *it;
2513075c896SRyan Stone 	const char *key;
2523075c896SRyan Stone 	void *value;
2533075c896SRyan Stone 	const void *ret_value;
2543075c896SRyan Stone 	size_t value_size, ret_size;
2553075c896SRyan Stone 	int type;
2563075c896SRyan Stone 
2573075c896SRyan Stone 	key = "binary";
2583075c896SRyan Stone 	value_size = 13;
2593075c896SRyan Stone 	value = malloc(value_size);
2603075c896SRyan Stone 	memset(value, 0xa5, value_size);
2613075c896SRyan Stone 	nvl = nvlist_create(0);
2623075c896SRyan Stone 
2633075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
2643075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
2653075c896SRyan Stone 
2663075c896SRyan Stone 	nvlist_add_binary(nvl, key, value, value_size);
2673075c896SRyan Stone 
2683075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
2693075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
2703075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
2713075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_binary(nvl, key));
2723075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key));
2733075c896SRyan Stone 
2743075c896SRyan Stone 	ret_value = nvlist_get_binary(nvl, key, &ret_size);
2753075c896SRyan Stone 	ATF_REQUIRE_EQ(value_size, ret_size);
2763075c896SRyan Stone 	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
2773075c896SRyan Stone 
2783075c896SRyan Stone 	/* nvlist_add_* is required to clone the value, so check for that. */
2793075c896SRyan Stone 	ATF_REQUIRE(value != ret_value);
2803075c896SRyan Stone 
2813075c896SRyan Stone 	ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key);
2823075c896SRyan Stone 	ATF_REQUIRE_EQ(value_size, ret_size);
2833075c896SRyan Stone 	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
2843075c896SRyan Stone 	ATF_REQUIRE(value != ret_value);
2853075c896SRyan Stone 
2863075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
2873075c896SRyan Stone 	it = NULL;
2883075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
2893075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
2903075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
2913075c896SRyan Stone 
2923075c896SRyan Stone 	nvlist_destroy(nvl);
2933075c896SRyan Stone 	free(value);
2943075c896SRyan Stone }
2953075c896SRyan Stone 
2966e623ffdSRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__empty_nvlist);
2976e623ffdSRyan Stone ATF_TEST_CASE_BODY(nvlist_clone__empty_nvlist)
2986e623ffdSRyan Stone {
2996e623ffdSRyan Stone 	nvlist_t *nvl, *clone;
3006e623ffdSRyan Stone 
3016e623ffdSRyan Stone 	nvl = nvlist_create(0);
3026e623ffdSRyan Stone 	ATF_REQUIRE(nvl != NULL);
3036e623ffdSRyan Stone 
3046e623ffdSRyan Stone 	clone = nvlist_clone(nvl);
3056e623ffdSRyan Stone 	ATF_REQUIRE(clone != NULL);
3066e623ffdSRyan Stone 	ATF_REQUIRE(clone != nvl);
3076e623ffdSRyan Stone 	ATF_REQUIRE(nvlist_empty(clone));
3086e623ffdSRyan Stone 
3096e623ffdSRyan Stone 	nvlist_destroy(clone);
3106e623ffdSRyan Stone 	nvlist_destroy(nvl);
3116e623ffdSRyan Stone }
3126e623ffdSRyan Stone 
3136e623ffdSRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nonempty_nvlist);
3146e623ffdSRyan Stone ATF_TEST_CASE_BODY(nvlist_clone__nonempty_nvlist)
3156e623ffdSRyan Stone {
3166e623ffdSRyan Stone 	nvlist_t *nvl, *clone;
3176e623ffdSRyan Stone 	const char *key;
3186e623ffdSRyan Stone 	void *it;
3196e623ffdSRyan Stone 	uint64_t value;
3206e623ffdSRyan Stone 	int type;
3216e623ffdSRyan Stone 
3226e623ffdSRyan Stone 	nvl = nvlist_create(0);
3236e623ffdSRyan Stone 	ATF_REQUIRE(nvl != NULL);
3246e623ffdSRyan Stone 
3256e623ffdSRyan Stone 	key = "testkey";
3266e623ffdSRyan Stone 	value = 684874;
3276e623ffdSRyan Stone 	nvlist_add_number(nvl, key, value);
3286e623ffdSRyan Stone 
3296e623ffdSRyan Stone 	clone = nvlist_clone(nvl);
3306e623ffdSRyan Stone 	ATF_REQUIRE(clone != NULL);
3316e623ffdSRyan Stone 	ATF_REQUIRE(clone != nvl);
3326e623ffdSRyan Stone 	ATF_REQUIRE(nvlist_exists_number(clone, key));
3336e623ffdSRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_number(clone, key), value);
3346e623ffdSRyan Stone 
3356e623ffdSRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
3366e623ffdSRyan Stone 	it = NULL;
3376e623ffdSRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(clone, &type, &it), key), 0);
3386e623ffdSRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
3396e623ffdSRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(clone, &type, &it), NULL);
3406e623ffdSRyan Stone 
3416e623ffdSRyan Stone 	nvlist_destroy(clone);
3426e623ffdSRyan Stone 	nvlist_destroy(nvl);
3436e623ffdSRyan Stone }
3446e623ffdSRyan Stone 
3456e623ffdSRyan Stone static const char * const test_subnvlist_key = "nvlist";
3466e623ffdSRyan Stone 
3476e623ffdSRyan Stone static const char * const test_string_key = "string";
3486e623ffdSRyan Stone static const char * const test_string_val = "59525";
3496e623ffdSRyan Stone 
3506e623ffdSRyan Stone static nvlist_t*
3516e623ffdSRyan Stone create_test_nvlist(void)
3526e623ffdSRyan Stone {
3536e623ffdSRyan Stone 	nvlist_t *nvl, *sublist;
3546e623ffdSRyan Stone 
3556e623ffdSRyan Stone 	nvl = nvlist_create(0);
3566e623ffdSRyan Stone 	ATF_REQUIRE(nvl != NULL);
3576e623ffdSRyan Stone 
3586e623ffdSRyan Stone 	sublist = nvlist_create(0);
3596e623ffdSRyan Stone 	ATF_REQUIRE(sublist != NULL);
3606e623ffdSRyan Stone 
3616e623ffdSRyan Stone 	nvlist_add_string(sublist, test_string_key, test_string_val);
3626e623ffdSRyan Stone 	nvlist_move_nvlist(nvl, test_subnvlist_key, sublist);
3636e623ffdSRyan Stone 
3646e623ffdSRyan Stone 	return (nvl);
3656e623ffdSRyan Stone }
3666e623ffdSRyan Stone 
3676e623ffdSRyan Stone static void
3686e623ffdSRyan Stone verify_test_nvlist(const nvlist_t *nvl)
3696e623ffdSRyan Stone {
3706e623ffdSRyan Stone 	void *it;
3716e623ffdSRyan Stone 	const nvlist_t *value;
3726e623ffdSRyan Stone 	int type;
3736e623ffdSRyan Stone 
3746e623ffdSRyan Stone 	ATF_REQUIRE(nvlist_exists_nvlist(nvl, test_subnvlist_key));
3756e623ffdSRyan Stone 
3766e623ffdSRyan Stone 	value = nvlist_get_nvlist(nvl, test_subnvlist_key);
3776e623ffdSRyan Stone 
3786e623ffdSRyan Stone 	ATF_REQUIRE(nvlist_exists_string(value, test_string_key));
3796e623ffdSRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(value, test_string_key), test_string_val), 0);
3806e623ffdSRyan Stone 	ATF_REQUIRE(nvlist_get_string(value, test_string_key) != test_string_val);
3816e623ffdSRyan Stone 
3826e623ffdSRyan Stone 	/* Iterate over both nvlists; ensure that each has only the one key. */
3836e623ffdSRyan Stone 	it = NULL;
3846e623ffdSRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(value, &type, &it),
3856e623ffdSRyan Stone 	    test_string_key), 0);
3866e623ffdSRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
3876e623ffdSRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(value, &type, &it), NULL);
3886e623ffdSRyan Stone 
3896e623ffdSRyan Stone 	it = NULL;
3906e623ffdSRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it),
3916e623ffdSRyan Stone 	    test_subnvlist_key), 0);
3926e623ffdSRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
3936e623ffdSRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL);
3946e623ffdSRyan Stone }
3956e623ffdSRyan Stone 
3966e623ffdSRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nested_nvlist);
3976e623ffdSRyan Stone ATF_TEST_CASE_BODY(nvlist_clone__nested_nvlist)
3986e623ffdSRyan Stone {
3996e623ffdSRyan Stone 	nvlist_t *nvl, *clone;
4006e623ffdSRyan Stone 
4016e623ffdSRyan Stone 	nvl = create_test_nvlist();
4026e623ffdSRyan Stone 	clone = nvlist_clone(nvl);
4036e623ffdSRyan Stone 
4046e623ffdSRyan Stone 	ATF_REQUIRE(clone != NULL);
4056e623ffdSRyan Stone 	ATF_REQUIRE(clone != nvl);
4066e623ffdSRyan Stone 	verify_test_nvlist(clone);
4076e623ffdSRyan Stone 
4086e623ffdSRyan Stone 	nvlist_destroy(clone);
4096e623ffdSRyan Stone 	nvlist_destroy(nvl);
4106e623ffdSRyan Stone }
4116e623ffdSRyan Stone 
412*a87e5162SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__error_nvlist);
413*a87e5162SRyan Stone ATF_TEST_CASE_BODY(nvlist_clone__error_nvlist)
414*a87e5162SRyan Stone {
415*a87e5162SRyan Stone 	nvlist_t *nvl, *clone;
416*a87e5162SRyan Stone 
417*a87e5162SRyan Stone 	nvl = nvlist_create(0);
418*a87e5162SRyan Stone 	ATF_REQUIRE(nvl != NULL);
419*a87e5162SRyan Stone 
420*a87e5162SRyan Stone 	nvlist_set_error(nvl, ENOMEM);
421*a87e5162SRyan Stone 
422*a87e5162SRyan Stone 	clone = nvlist_clone(nvl);
423*a87e5162SRyan Stone 	ATF_REQUIRE(clone == NULL);
424*a87e5162SRyan Stone 
425*a87e5162SRyan Stone 	nvlist_destroy(nvl);
426*a87e5162SRyan Stone }
427*a87e5162SRyan Stone 
4286c721f82SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__empty_nvlist);
4296c721f82SRyan Stone ATF_TEST_CASE_BODY(nvlist_pack__empty_nvlist)
4306c721f82SRyan Stone {
4316c721f82SRyan Stone 	nvlist_t *nvl, *unpacked;
4326c721f82SRyan Stone 	void *packed;
4336c721f82SRyan Stone 	size_t packed_size;
4346c721f82SRyan Stone 
4356c721f82SRyan Stone 	nvl = nvlist_create(0);
4366c721f82SRyan Stone 	ATF_REQUIRE(nvl != NULL);
4376c721f82SRyan Stone 
4386c721f82SRyan Stone 	packed = nvlist_pack(nvl, &packed_size);
4396c721f82SRyan Stone 	ATF_REQUIRE(packed != NULL);
4406c721f82SRyan Stone 
4416c721f82SRyan Stone 	unpacked = nvlist_unpack(packed, packed_size);
4426c721f82SRyan Stone 	ATF_REQUIRE(unpacked != NULL);
4436c721f82SRyan Stone 	ATF_REQUIRE(unpacked != nvl);
4446c721f82SRyan Stone 	ATF_REQUIRE(nvlist_empty(unpacked));
4456c721f82SRyan Stone 
4466c721f82SRyan Stone 	nvlist_destroy(unpacked);
4476c721f82SRyan Stone 	nvlist_destroy(nvl);
4486c721f82SRyan Stone 	free(packed);
4496c721f82SRyan Stone }
4506c721f82SRyan Stone 
4516c721f82SRyan Stone static void
4526c721f82SRyan Stone verify_null(const nvlist_t *nvl, int type)
4536c721f82SRyan Stone {
4546c721f82SRyan Stone 
4556c721f82SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
4566c721f82SRyan Stone }
4576c721f82SRyan Stone 
4586c721f82SRyan Stone static void
4596c721f82SRyan Stone verify_number(const nvlist_t *nvl, const char *name, int type, uint64_t value)
4606c721f82SRyan Stone {
4616c721f82SRyan Stone 
4626c721f82SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
4636c721f82SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_number(nvl, name), value);
4646c721f82SRyan Stone }
4656c721f82SRyan Stone 
4666c721f82SRyan Stone static void
4676c721f82SRyan Stone verify_string(const nvlist_t *nvl, const char *name, int type,
4686c721f82SRyan Stone     const char * value)
4696c721f82SRyan Stone {
4706c721f82SRyan Stone 
4716c721f82SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
4726c721f82SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, name), value), 0);
4736c721f82SRyan Stone }
4746c721f82SRyan Stone 
4756c721f82SRyan Stone static void
4766c721f82SRyan Stone verify_nvlist(const nvlist_t *nvl, const char *name, int type)
4776c721f82SRyan Stone {
4786c721f82SRyan Stone 
4796c721f82SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
4806c721f82SRyan Stone 	verify_test_nvlist(nvlist_get_nvlist(nvl, name));
4816c721f82SRyan Stone }
4826c721f82SRyan Stone 
4836c721f82SRyan Stone static void
4846c721f82SRyan Stone verify_binary(const nvlist_t *nvl, const char *name, int type,
4856c721f82SRyan Stone     const void * value, size_t size)
4866c721f82SRyan Stone {
4876c721f82SRyan Stone 	const void *actual_value;
4886c721f82SRyan Stone 	size_t actual_size;
4896c721f82SRyan Stone 
4906c721f82SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
4916c721f82SRyan Stone 	actual_value = nvlist_get_binary(nvl, name, &actual_size);
4926c721f82SRyan Stone 	ATF_REQUIRE_EQ(size, actual_size);
4936c721f82SRyan Stone 	ATF_REQUIRE_EQ(memcmp(value, actual_value, size), 0);
4946c721f82SRyan Stone }
4956c721f82SRyan Stone 
4966c721f82SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__multiple_values);
4976c721f82SRyan Stone ATF_TEST_CASE_BODY(nvlist_pack__multiple_values)
4986c721f82SRyan Stone {
4996c721f82SRyan Stone 	std::ostringstream msg;
5006c721f82SRyan Stone 	std::set<std::string> keys_seen;
5016c721f82SRyan Stone 	nvlist_t *nvl, *unpacked, *nvvalue;
5026c721f82SRyan Stone 	const char *nullkey, *numkey, *strkey, *nvkey, *binkey, *name;
5036c721f82SRyan Stone 	int numvalue;
5046c721f82SRyan Stone 	const char * strvalue;
5056c721f82SRyan Stone 	void *binvalue, *packed, *it;
5066c721f82SRyan Stone 	size_t binsize, packed_size;
5076c721f82SRyan Stone 	int type;
5086c721f82SRyan Stone 
5096c721f82SRyan Stone 	nvl = nvlist_create(0);
5106c721f82SRyan Stone 
5116c721f82SRyan Stone 	nullkey = "null";
5126c721f82SRyan Stone 	nvlist_add_null(nvl, nullkey);
5136c721f82SRyan Stone 
5146c721f82SRyan Stone 	numkey = "number";
5156c721f82SRyan Stone 	numvalue = 939853984;
5166c721f82SRyan Stone 	nvlist_add_number(nvl, numkey, numvalue);
5176c721f82SRyan Stone 
5186c721f82SRyan Stone 	strkey = "string";
5196c721f82SRyan Stone 	strvalue = "jfieutijf";
5206c721f82SRyan Stone 	nvlist_add_string(nvl, strkey, strvalue);
5216c721f82SRyan Stone 
5226c721f82SRyan Stone 	nvkey = "nvlist";
5236c721f82SRyan Stone 	nvvalue = create_test_nvlist();
5246c721f82SRyan Stone 	nvlist_move_nvlist(nvl, nvkey, nvvalue);
5256c721f82SRyan Stone 
5266c721f82SRyan Stone 	binkey = "binary";
5276c721f82SRyan Stone 	binsize = 4;
5286c721f82SRyan Stone 	binvalue = malloc(binsize);
5296c721f82SRyan Stone 	memset(binvalue, 'b', binsize);
5306c721f82SRyan Stone 	nvlist_move_binary(nvl, binkey, binvalue, binsize);
5316c721f82SRyan Stone 
5326c721f82SRyan Stone 	packed = nvlist_pack(nvl, &packed_size);
5336c721f82SRyan Stone 	ATF_REQUIRE(packed != NULL);
5346c721f82SRyan Stone 
5356c721f82SRyan Stone 	unpacked = nvlist_unpack(packed, packed_size);
5366c721f82SRyan Stone 	ATF_REQUIRE(unpacked != 0);
5376c721f82SRyan Stone 
5386c721f82SRyan Stone 	it = NULL;
5396c721f82SRyan Stone 	while ((name = nvlist_next(unpacked, &type, &it)) != NULL) {
5406c721f82SRyan Stone 		/* Ensure that we see every key only once. */
5416c721f82SRyan Stone 		ATF_REQUIRE_EQ(keys_seen.count(name), 0);
5426c721f82SRyan Stone 
5436c721f82SRyan Stone 		if (strcmp(name, nullkey) == 0)
5446c721f82SRyan Stone 			verify_null(unpacked, type);
5456c721f82SRyan Stone 		else if (strcmp(name, numkey) == 0)
5466c721f82SRyan Stone 			verify_number(unpacked, name, type, numvalue);
5476c721f82SRyan Stone 		else if (strcmp(name, strkey) == 0)
5486c721f82SRyan Stone 			verify_string(unpacked, name, type, strvalue);
5496c721f82SRyan Stone 		else if (strcmp(name, nvkey) == 0)
5506c721f82SRyan Stone 			verify_nvlist(unpacked, name, type);
5516c721f82SRyan Stone 		else if (strcmp(name, binkey) == 0)
5526c721f82SRyan Stone 			verify_binary(unpacked, name, type, binvalue, binsize);
5536c721f82SRyan Stone 		else {
5546c721f82SRyan Stone 			msg << "Unexpected key :'" << name << "'";
5556c721f82SRyan Stone 			ATF_FAIL(msg.str().c_str());
5566c721f82SRyan Stone 		}
5576c721f82SRyan Stone 
5586c721f82SRyan Stone 		keys_seen.insert(name);
5596c721f82SRyan Stone 	}
5606c721f82SRyan Stone 
5616c721f82SRyan Stone 	/* Ensure that we saw every key. */
5626c721f82SRyan Stone 	ATF_REQUIRE_EQ(keys_seen.size(), 5);
5636c721f82SRyan Stone 
5646c721f82SRyan Stone 	nvlist_destroy(nvl);
5656c721f82SRyan Stone 	nvlist_destroy(unpacked);
5666c721f82SRyan Stone 	free(packed);
5676c721f82SRyan Stone }
5686c721f82SRyan Stone 
569*a87e5162SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__error_nvlist);
570*a87e5162SRyan Stone ATF_TEST_CASE_BODY(nvlist_pack__error_nvlist)
571*a87e5162SRyan Stone {
572*a87e5162SRyan Stone 	nvlist_t *nvl;
573*a87e5162SRyan Stone 	void *packed;
574*a87e5162SRyan Stone 	size_t size;
575*a87e5162SRyan Stone 
576*a87e5162SRyan Stone 	nvl = nvlist_create(0);
577*a87e5162SRyan Stone 	ATF_REQUIRE(nvl != NULL);
578*a87e5162SRyan Stone 
579*a87e5162SRyan Stone 	nvlist_set_error(nvl, ENOMEM);
580*a87e5162SRyan Stone 
581*a87e5162SRyan Stone 	packed = nvlist_pack(nvl, &size);
582*a87e5162SRyan Stone 	ATF_REQUIRE(packed == NULL);
583*a87e5162SRyan Stone 
584*a87e5162SRyan Stone 	nvlist_destroy(nvl);
585*a87e5162SRyan Stone }
586*a87e5162SRyan Stone 
5876c721f82SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__duplicate_key);
5886c721f82SRyan Stone ATF_TEST_CASE_BODY(nvlist_unpack__duplicate_key)
5896c721f82SRyan Stone {
5906c721f82SRyan Stone 	nvlist_t *nvl, *unpacked;
5916c721f82SRyan Stone 	const char *key1, *key2;
5926c721f82SRyan Stone 	void *packed, *keypos;
5936c721f82SRyan Stone 	size_t size, keylen;
5946c721f82SRyan Stone 
5956c721f82SRyan Stone 	nvl = nvlist_create(0);
5966c721f82SRyan Stone 
5976c721f82SRyan Stone 	key1 = "key1";
5986c721f82SRyan Stone 	keylen = strlen(key1);
5996c721f82SRyan Stone 	nvlist_add_number(nvl, key1, 5);
6006c721f82SRyan Stone 
6016c721f82SRyan Stone 	key2 = "key2";
6026c721f82SRyan Stone 	ATF_REQUIRE_EQ(keylen, strlen(key2));
6036c721f82SRyan Stone 	nvlist_add_number(nvl, key2, 10);
6046c721f82SRyan Stone 
6056c721f82SRyan Stone 	packed = nvlist_pack(nvl, &size);
6066c721f82SRyan Stone 
6076c721f82SRyan Stone 	/*
6086c721f82SRyan Stone 	 * Mangle the packed nvlist by replacing key1 with key2, creating a
6096c721f82SRyan Stone 	 * packed nvlist with a duplicate key.
6106c721f82SRyan Stone 	 */
6116c721f82SRyan Stone 	keypos = memmem(packed, size, key1, keylen);
6126c721f82SRyan Stone 	ATF_REQUIRE(keypos != NULL);
6136c721f82SRyan Stone 	memcpy(keypos, key2, keylen);
6146c721f82SRyan Stone 
6156c721f82SRyan Stone 	unpacked = nvlist_unpack(packed, size);
6166c721f82SRyan Stone 	ATF_REQUIRE(nvlist_error(unpacked) != 0);
6176c721f82SRyan Stone 
6186c721f82SRyan Stone 	free(packed);
6196c721f82SRyan Stone 	nvlist_destroy(nvl);
6206c721f82SRyan Stone 	nvlist_destroy(unpacked);
6216c721f82SRyan Stone }
6226c721f82SRyan Stone 
62371637d76SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_string__single_insert);
62471637d76SRyan Stone ATF_TEST_CASE_BODY(nvlist_move_string__single_insert)
62571637d76SRyan Stone {
62671637d76SRyan Stone 	nvlist_t *nvl;
62771637d76SRyan Stone 	const char *key;
62871637d76SRyan Stone 	char *value;
62971637d76SRyan Stone 
63071637d76SRyan Stone 	nvl = nvlist_create(0);
63171637d76SRyan Stone 	ATF_REQUIRE(nvl != NULL);
63271637d76SRyan Stone 
63371637d76SRyan Stone 	key = "testkey";
63471637d76SRyan Stone 	value = strdup("testval");
63571637d76SRyan Stone 	ATF_REQUIRE(value != NULL);
63671637d76SRyan Stone 
63771637d76SRyan Stone 	nvlist_move_string(nvl, key, value);
63871637d76SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_string(nvl, key), value);
63971637d76SRyan Stone 
64071637d76SRyan Stone 	nvlist_destroy(nvl);
64171637d76SRyan Stone }
64271637d76SRyan Stone 
64371637d76SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__null_child);
64471637d76SRyan Stone ATF_TEST_CASE_BODY(nvlist_move_nvlist__null_child)
64571637d76SRyan Stone {
64671637d76SRyan Stone 	nvlist_t *parent;
64771637d76SRyan Stone 
64871637d76SRyan Stone 	parent = nvlist_create(0);
64971637d76SRyan Stone 
65071637d76SRyan Stone 	nvlist_move_nvlist(parent, "test", NULL);
65171637d76SRyan Stone 
65271637d76SRyan Stone 	ATF_REQUIRE(nvlist_error(parent) != 0);
65371637d76SRyan Stone 
65471637d76SRyan Stone 	nvlist_destroy(parent);
65571637d76SRyan Stone }
65671637d76SRyan Stone 
65771637d76SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__single_insert);
65871637d76SRyan Stone ATF_TEST_CASE_BODY(nvlist_move_nvlist__single_insert)
65971637d76SRyan Stone {
66071637d76SRyan Stone 	nvlist_t *nvl;
66171637d76SRyan Stone 	const char *key;
66271637d76SRyan Stone 	nvlist_t *value;
66371637d76SRyan Stone 
66471637d76SRyan Stone 	nvl = nvlist_create(0);
66571637d76SRyan Stone 	ATF_REQUIRE(nvl != NULL);
66671637d76SRyan Stone 
66771637d76SRyan Stone 	key = "testkey";
66871637d76SRyan Stone 	value = nvlist_create(0);
66971637d76SRyan Stone 	ATF_REQUIRE(value != NULL);
67071637d76SRyan Stone 
67171637d76SRyan Stone 	nvlist_move_nvlist(nvl, key, value);
67271637d76SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_nvlist(nvl, key), value);
67371637d76SRyan Stone 
67471637d76SRyan Stone 	nvlist_destroy(nvl);
67571637d76SRyan Stone }
67671637d76SRyan Stone 
67771637d76SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_binary__single_insert);
67871637d76SRyan Stone ATF_TEST_CASE_BODY(nvlist_move_binary__single_insert)
67971637d76SRyan Stone {
68071637d76SRyan Stone 	nvlist_t *nvl;
68171637d76SRyan Stone 	const char *key;
68271637d76SRyan Stone 	void *value;
68371637d76SRyan Stone 	size_t size, actual_size;
68471637d76SRyan Stone 
68571637d76SRyan Stone 	nvl = nvlist_create(0);
68671637d76SRyan Stone 	ATF_REQUIRE(nvl != NULL);
68771637d76SRyan Stone 
68871637d76SRyan Stone 	key = "testkey";
68971637d76SRyan Stone 	size = 73;
69071637d76SRyan Stone 	value = malloc(size);
69171637d76SRyan Stone 	ATF_REQUIRE(value != NULL);
69271637d76SRyan Stone 
69371637d76SRyan Stone 	nvlist_move_binary(nvl, key, value, size);
69471637d76SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_binary(nvl, key, &actual_size), value);
69571637d76SRyan Stone 	ATF_REQUIRE_EQ(size, actual_size);
69671637d76SRyan Stone 
69771637d76SRyan Stone 	nvlist_destroy(nvl);
69871637d76SRyan Stone }
69971637d76SRyan Stone 
700fad0a264SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__single_remove);
701fad0a264SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_bool__single_remove)
702fad0a264SRyan Stone {
703fad0a264SRyan Stone 	nvlist_t *nvl;
704fad0a264SRyan Stone 	const char *testkey;
705fad0a264SRyan Stone 	bool testval;
706fad0a264SRyan Stone 
707fad0a264SRyan Stone 	nvl = nvlist_create(0);
708fad0a264SRyan Stone 	ATF_REQUIRE(nvl != NULL);
709fad0a264SRyan Stone 
710fad0a264SRyan Stone 	testkey = "boolkey";
711fad0a264SRyan Stone 	testval = false;
712fad0a264SRyan Stone 	nvlist_add_bool(nvl, testkey, testval);
713fad0a264SRyan Stone 
714fad0a264SRyan Stone 	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
715fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
716fad0a264SRyan Stone 
717fad0a264SRyan Stone 	nvlist_destroy(nvl);
718fad0a264SRyan Stone }
719fad0a264SRyan Stone 
720fad0a264SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__other_keys_unchanged);
721fad0a264SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_bool__other_keys_unchanged)
722fad0a264SRyan Stone {
723fad0a264SRyan Stone 	nvlist_t *nvl;
724fad0a264SRyan Stone 	const char *testkey, *otherkey1, *otherkey2;
725fad0a264SRyan Stone 	bool testval, otherval1;
726fad0a264SRyan Stone 	nvlist_t *otherval2;
727fad0a264SRyan Stone 
728fad0a264SRyan Stone 	nvl = nvlist_create(0);
729fad0a264SRyan Stone 	ATF_REQUIRE(nvl != NULL);
730fad0a264SRyan Stone 
731fad0a264SRyan Stone 	testkey = "boolkey";
732fad0a264SRyan Stone 	testval = true;
733fad0a264SRyan Stone 	nvlist_add_bool(nvl, testkey, testval);
734fad0a264SRyan Stone 
735fad0a264SRyan Stone 	otherkey1 = "key1";
736fad0a264SRyan Stone 	otherval1 = false;
737fad0a264SRyan Stone 	nvlist_add_bool(nvl, otherkey1, otherval1);
738fad0a264SRyan Stone 
739fad0a264SRyan Stone 	otherkey2 = "key2";
740fad0a264SRyan Stone 	otherval2 = create_test_nvlist();
741fad0a264SRyan Stone 	nvlist_move_nvlist(nvl, otherkey2, otherval2);
742fad0a264SRyan Stone 
743fad0a264SRyan Stone 	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
744fad0a264SRyan Stone 
745fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey1));
746fad0a264SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey1), otherval1);
747fad0a264SRyan Stone 
748fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey2));
749fad0a264SRyan Stone 	verify_test_nvlist(nvlist_get_nvlist(nvl, otherkey2));
750fad0a264SRyan Stone 
751fad0a264SRyan Stone 	nvlist_destroy(nvl);
752fad0a264SRyan Stone }
753fad0a264SRyan Stone 
754fad0a264SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__single_remove);
755fad0a264SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_number__single_remove)
756fad0a264SRyan Stone {
757fad0a264SRyan Stone 	nvlist_t *nvl;
758fad0a264SRyan Stone 	const char *testkey;
759fad0a264SRyan Stone 	uint64_t testval;
760fad0a264SRyan Stone 
761fad0a264SRyan Stone 	nvl = nvlist_create(0);
762fad0a264SRyan Stone 	ATF_REQUIRE(nvl != NULL);
763fad0a264SRyan Stone 
764fad0a264SRyan Stone 	testkey = "numkey";
765fad0a264SRyan Stone 	testval = std::numeric_limits<uint64_t>::max();
766fad0a264SRyan Stone 	nvlist_add_number(nvl, testkey, testval);
767fad0a264SRyan Stone 
768fad0a264SRyan Stone 	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
769fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
770fad0a264SRyan Stone 
771fad0a264SRyan Stone 	nvlist_destroy(nvl);
772fad0a264SRyan Stone }
773fad0a264SRyan Stone 
774fad0a264SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__other_keys_unchanged);
775fad0a264SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_number__other_keys_unchanged)
776fad0a264SRyan Stone {
777fad0a264SRyan Stone 	nvlist_t *nvl;
778fad0a264SRyan Stone 	const char *testkey, *otherkey1, *otherkey2;
779fad0a264SRyan Stone 	uint64_t testval, otherval1;
780fad0a264SRyan Stone 	const char *otherval2;
781fad0a264SRyan Stone 
782fad0a264SRyan Stone 	nvl = nvlist_create(0);
783fad0a264SRyan Stone 	ATF_REQUIRE(nvl != NULL);
784fad0a264SRyan Stone 
785fad0a264SRyan Stone 	otherkey1 = "key1";
786fad0a264SRyan Stone 	otherval1 = 5;
787fad0a264SRyan Stone 	nvlist_add_number(nvl, otherkey1, otherval1);
788fad0a264SRyan Stone 
789fad0a264SRyan Stone 	testkey = "numkey";
790fad0a264SRyan Stone 	testval = 1654;
791fad0a264SRyan Stone 	nvlist_add_number(nvl, testkey, testval);
792fad0a264SRyan Stone 
793fad0a264SRyan Stone 	otherkey2 = "key2";
794fad0a264SRyan Stone 	otherval2 = "string";
795fad0a264SRyan Stone 	nvlist_add_string(nvl, otherkey2, otherval2);
796fad0a264SRyan Stone 
797fad0a264SRyan Stone 	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
798fad0a264SRyan Stone 
799fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_exists_number(nvl, otherkey1));
800fad0a264SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_number(nvl, otherkey1), otherval1);
801fad0a264SRyan Stone 
802fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey2));
803fad0a264SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey2), otherval2), 0);
804fad0a264SRyan Stone 
805fad0a264SRyan Stone 	nvlist_destroy(nvl);
806fad0a264SRyan Stone }
807fad0a264SRyan Stone 
808fad0a264SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__single_remove);
809fad0a264SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_string__single_remove)
810fad0a264SRyan Stone {
811fad0a264SRyan Stone 	nvlist_t *nvl;
812fad0a264SRyan Stone 	const char *testkey;
813fad0a264SRyan Stone 	const char *testval;
814fad0a264SRyan Stone 
815fad0a264SRyan Stone 	nvl = nvlist_create(0);
816fad0a264SRyan Stone 	ATF_REQUIRE(nvl != NULL);
817fad0a264SRyan Stone 
818fad0a264SRyan Stone 	testkey = "numkey";
819fad0a264SRyan Stone 	testval = "nvlist";
820fad0a264SRyan Stone 	nvlist_add_string(nvl, testkey, testval);
821fad0a264SRyan Stone 
822fad0a264SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
823fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
824fad0a264SRyan Stone 
825fad0a264SRyan Stone 	nvlist_destroy(nvl);
826fad0a264SRyan Stone }
827fad0a264SRyan Stone 
828fad0a264SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__other_keys_unchanged);
829fad0a264SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_string__other_keys_unchanged)
830fad0a264SRyan Stone {
831fad0a264SRyan Stone 	nvlist_t *nvl;
832fad0a264SRyan Stone 	const char *testkey, *otherkey1, *otherkey2;
833fad0a264SRyan Stone 	const char *testval, *otherval1;
834fad0a264SRyan Stone 	bool otherval2;
835fad0a264SRyan Stone 
836fad0a264SRyan Stone 	nvl = nvlist_create(0);
837fad0a264SRyan Stone 	ATF_REQUIRE(nvl != NULL);
838fad0a264SRyan Stone 
839fad0a264SRyan Stone 	otherkey1 = "key1";
840fad0a264SRyan Stone 	otherval1 = "fjdifjdk";
841fad0a264SRyan Stone 	nvlist_add_string(nvl, otherkey1, otherval1);
842fad0a264SRyan Stone 
843fad0a264SRyan Stone 	otherkey2 = "key2";
844fad0a264SRyan Stone 	otherval2 = true;
845fad0a264SRyan Stone 	nvlist_add_bool(nvl, otherkey2, otherval2);
846fad0a264SRyan Stone 
847fad0a264SRyan Stone 	testkey = "strkey";
848fad0a264SRyan Stone 	testval = "1654";
849fad0a264SRyan Stone 	nvlist_add_string(nvl, testkey, testval);
850fad0a264SRyan Stone 
851fad0a264SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
852fad0a264SRyan Stone 
853fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey1));
854fad0a264SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey1), otherval1), 0);
855fad0a264SRyan Stone 
856fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
857fad0a264SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
858fad0a264SRyan Stone 
859fad0a264SRyan Stone 	nvlist_destroy(nvl);
860fad0a264SRyan Stone }
861fad0a264SRyan Stone 
862fad0a264SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__single_remove);
863fad0a264SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_nvlist__single_remove)
864fad0a264SRyan Stone {
865fad0a264SRyan Stone 	nvlist_t *nvl;
866fad0a264SRyan Stone 	const char *testkey;
867fad0a264SRyan Stone 	nvlist_t *testval;
868fad0a264SRyan Stone 
869fad0a264SRyan Stone 	nvl = nvlist_create(0);
870fad0a264SRyan Stone 	ATF_REQUIRE(nvl != NULL);
871fad0a264SRyan Stone 
872fad0a264SRyan Stone 	testkey = "numkey";
873fad0a264SRyan Stone 	testval = create_test_nvlist();
874fad0a264SRyan Stone 	nvlist_move_nvlist(nvl, testkey, testval);
875fad0a264SRyan Stone 
876fad0a264SRyan Stone 	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
877fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
878fad0a264SRyan Stone 
879fad0a264SRyan Stone 	nvlist_destroy(nvl);
880fad0a264SRyan Stone }
881fad0a264SRyan Stone 
882fad0a264SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__other_keys_unchanged);
883fad0a264SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_nvlist__other_keys_unchanged)
884fad0a264SRyan Stone {
885fad0a264SRyan Stone 	nvlist_t *nvl;
886fad0a264SRyan Stone 	const char *testkey, *otherkey1, *otherkey2;
887fad0a264SRyan Stone 	nvlist_t *testval, *otherval1;
888fad0a264SRyan Stone 
889fad0a264SRyan Stone 	nvl = nvlist_create(0);
890fad0a264SRyan Stone 	ATF_REQUIRE(nvl != NULL);
891fad0a264SRyan Stone 
892fad0a264SRyan Stone 	testkey = "strkey";
893fad0a264SRyan Stone 	testval = create_test_nvlist();
894fad0a264SRyan Stone 	nvlist_move_nvlist(nvl, testkey, testval);
895fad0a264SRyan Stone 
896fad0a264SRyan Stone 	otherkey1 = "key1";
897fad0a264SRyan Stone 	otherval1 = nvlist_create(0);
898fad0a264SRyan Stone 	nvlist_move_nvlist(nvl, otherkey1, otherval1);
899fad0a264SRyan Stone 
900fad0a264SRyan Stone 	otherkey2 = "key2";
901fad0a264SRyan Stone 	nvlist_add_null(nvl, otherkey2);
902fad0a264SRyan Stone 
903fad0a264SRyan Stone 	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
904fad0a264SRyan Stone 
905fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey1));
906fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvlist_get_nvlist(nvl, otherkey1)));
907fad0a264SRyan Stone 
908fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(nvl, otherkey2));
909fad0a264SRyan Stone 
910fad0a264SRyan Stone 	nvlist_destroy(nvl);
911fad0a264SRyan Stone }
912fad0a264SRyan Stone 
913fad0a264SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__single_remove);
914fad0a264SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_binary__single_remove)
915fad0a264SRyan Stone {
916fad0a264SRyan Stone 	nvlist_t *nvl;
917fad0a264SRyan Stone 	const char *testkey;
918fad0a264SRyan Stone 	void *testval;
919fad0a264SRyan Stone 	const void *actual_val;
920fad0a264SRyan Stone 	size_t testsize, actual_size;
921fad0a264SRyan Stone 
922fad0a264SRyan Stone 	nvl = nvlist_create(0);
923fad0a264SRyan Stone 	ATF_REQUIRE(nvl != NULL);
924fad0a264SRyan Stone 
925fad0a264SRyan Stone 	testkey = "numkey";
926fad0a264SRyan Stone 	testsize = 457;
927fad0a264SRyan Stone 	testval = malloc(testsize);
928fad0a264SRyan Stone 	memset(testval, '5', testsize);
929fad0a264SRyan Stone 	nvlist_move_binary(nvl, testkey, testval, testsize);
930fad0a264SRyan Stone 
931fad0a264SRyan Stone 	actual_val = nvlist_take_binary(nvl, testkey, &actual_size);
932fad0a264SRyan Stone 	ATF_REQUIRE_EQ(testsize, actual_size);
933fad0a264SRyan Stone 	ATF_REQUIRE_EQ(memcmp(actual_val, testval, testsize), 0);
934fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
935fad0a264SRyan Stone 
936fad0a264SRyan Stone 	nvlist_destroy(nvl);
937fad0a264SRyan Stone }
938fad0a264SRyan Stone 
939fad0a264SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__other_keys_unchanged);
940fad0a264SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_binary__other_keys_unchanged)
941fad0a264SRyan Stone {
942fad0a264SRyan Stone 	nvlist_t *nvl;
943fad0a264SRyan Stone 	const char *testkey, *otherkey1, *otherkey2;
944fad0a264SRyan Stone 	const void *actual_value;
945fad0a264SRyan Stone 	char testval[] = "gjiertj";
946fad0a264SRyan Stone 	char otherval1[] = "fdreg";
947fad0a264SRyan Stone 	size_t testsize, othersize, actual_size;
948fad0a264SRyan Stone 	bool otherval2;
949fad0a264SRyan Stone 
950fad0a264SRyan Stone 	nvl = nvlist_create(0);
951fad0a264SRyan Stone 	ATF_REQUIRE(nvl != NULL);
952fad0a264SRyan Stone 
953fad0a264SRyan Stone 	otherkey1 = "key1";
954fad0a264SRyan Stone 	othersize = sizeof(otherval1);
955fad0a264SRyan Stone 	nvlist_add_binary(nvl, otherkey1, otherval1, othersize);
956fad0a264SRyan Stone 
957fad0a264SRyan Stone 	otherkey2 = "key2";
958fad0a264SRyan Stone 	otherval2 = true;
959fad0a264SRyan Stone 	nvlist_add_bool(nvl, otherkey2, otherval2);
960fad0a264SRyan Stone 
961fad0a264SRyan Stone 	testkey = "strkey";
962fad0a264SRyan Stone 	testsize = sizeof(testval);
963fad0a264SRyan Stone 	nvlist_add_binary(nvl, testkey, testval, testsize);
964fad0a264SRyan Stone 
965fad0a264SRyan Stone 	actual_value = nvlist_take_binary(nvl, testkey, &actual_size);
966fad0a264SRyan Stone 	ATF_REQUIRE_EQ(testsize, actual_size);
967fad0a264SRyan Stone 	ATF_REQUIRE_EQ(memcmp(actual_value, testval, testsize), 0);
968fad0a264SRyan Stone 
969fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_exists_binary(nvl, otherkey1));
970fad0a264SRyan Stone 	actual_value = nvlist_get_binary(nvl, otherkey1, &actual_size);
971fad0a264SRyan Stone 	ATF_REQUIRE_EQ(othersize, actual_size);
972fad0a264SRyan Stone 	ATF_REQUIRE_EQ(memcmp(actual_value, otherval1, othersize), 0);
973fad0a264SRyan Stone 
974fad0a264SRyan Stone 	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
975fad0a264SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
976fad0a264SRyan Stone 
977fad0a264SRyan Stone 	nvlist_destroy(nvl);
978fad0a264SRyan Stone }
979fad0a264SRyan Stone 
980339bcfc7SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_null);
981339bcfc7SRyan Stone ATF_TEST_CASE_BODY(nvlist_free__single_null)
982339bcfc7SRyan Stone {
983339bcfc7SRyan Stone 	nvlist_t *nvl;
984339bcfc7SRyan Stone 	const char *key;
985339bcfc7SRyan Stone 
986339bcfc7SRyan Stone 	nvl = nvlist_create(0);
987339bcfc7SRyan Stone 	key = "test";
988339bcfc7SRyan Stone 	nvlist_add_null(nvl, key);
989339bcfc7SRyan Stone 
990339bcfc7SRyan Stone 	nvlist_free(nvl, key);
991339bcfc7SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
992339bcfc7SRyan Stone 
993339bcfc7SRyan Stone 	nvlist_destroy(nvl);
994339bcfc7SRyan Stone }
995339bcfc7SRyan Stone 
996339bcfc7SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_bool);
997339bcfc7SRyan Stone ATF_TEST_CASE_BODY(nvlist_free__single_bool)
998339bcfc7SRyan Stone {
999339bcfc7SRyan Stone 	nvlist_t *nvl;
1000339bcfc7SRyan Stone 	const char *key;
1001339bcfc7SRyan Stone 
1002339bcfc7SRyan Stone 	nvl = nvlist_create(0);
1003339bcfc7SRyan Stone 	key = "test";
1004339bcfc7SRyan Stone 	nvlist_add_bool(nvl, key, true);
1005339bcfc7SRyan Stone 
1006339bcfc7SRyan Stone 	nvlist_free(nvl, key);
1007339bcfc7SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
1008339bcfc7SRyan Stone 
1009339bcfc7SRyan Stone 	nvlist_destroy(nvl);
1010339bcfc7SRyan Stone }
1011339bcfc7SRyan Stone 
1012339bcfc7SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_number);
1013339bcfc7SRyan Stone ATF_TEST_CASE_BODY(nvlist_free__single_number)
1014339bcfc7SRyan Stone {
1015339bcfc7SRyan Stone 	nvlist_t *nvl;
1016339bcfc7SRyan Stone 	const char *key;
1017339bcfc7SRyan Stone 
1018339bcfc7SRyan Stone 	nvl = nvlist_create(0);
1019339bcfc7SRyan Stone 	key = "test";
1020339bcfc7SRyan Stone 	nvlist_add_number(nvl, key, 584);
1021339bcfc7SRyan Stone 
1022339bcfc7SRyan Stone 	nvlist_free(nvl, key);
1023339bcfc7SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
1024339bcfc7SRyan Stone 
1025339bcfc7SRyan Stone 	nvlist_destroy(nvl);
1026339bcfc7SRyan Stone }
1027339bcfc7SRyan Stone 
1028339bcfc7SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_string);
1029339bcfc7SRyan Stone ATF_TEST_CASE_BODY(nvlist_free__single_string)
1030339bcfc7SRyan Stone {
1031339bcfc7SRyan Stone 	nvlist_t *nvl;
1032339bcfc7SRyan Stone 	const char *key;
1033339bcfc7SRyan Stone 
1034339bcfc7SRyan Stone 	nvl = nvlist_create(0);
1035339bcfc7SRyan Stone 	key = "test";
1036339bcfc7SRyan Stone 	nvlist_add_string(nvl, key, "gjkfkjd");
1037339bcfc7SRyan Stone 
1038339bcfc7SRyan Stone 	nvlist_free(nvl, key);
1039339bcfc7SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
1040339bcfc7SRyan Stone 
1041339bcfc7SRyan Stone 	nvlist_destroy(nvl);
1042339bcfc7SRyan Stone }
1043339bcfc7SRyan Stone 
1044339bcfc7SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_nvlist);
1045339bcfc7SRyan Stone ATF_TEST_CASE_BODY(nvlist_free__single_nvlist)
1046339bcfc7SRyan Stone {
1047339bcfc7SRyan Stone 	nvlist_t *nvl;
1048339bcfc7SRyan Stone 	const char *key;
1049339bcfc7SRyan Stone 
1050339bcfc7SRyan Stone 	nvl = nvlist_create(0);
1051339bcfc7SRyan Stone 	key = "test";
1052339bcfc7SRyan Stone 	nvlist_add_nvlist(nvl, key, nvlist_create(0));
1053339bcfc7SRyan Stone 
1054339bcfc7SRyan Stone 	nvlist_free(nvl, key);
1055339bcfc7SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
1056339bcfc7SRyan Stone 
1057339bcfc7SRyan Stone 	nvlist_destroy(nvl);
1058339bcfc7SRyan Stone }
1059339bcfc7SRyan Stone 
1060339bcfc7SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_binary);
1061339bcfc7SRyan Stone ATF_TEST_CASE_BODY(nvlist_free__single_binary)
1062339bcfc7SRyan Stone {
1063339bcfc7SRyan Stone 	nvlist_t *nvl;
1064339bcfc7SRyan Stone 	const char *key;
1065339bcfc7SRyan Stone 
1066339bcfc7SRyan Stone 	nvl = nvlist_create(0);
1067339bcfc7SRyan Stone 	key = "test";
1068339bcfc7SRyan Stone 	nvlist_add_binary(nvl, key, "jgjgfd", 6);
1069339bcfc7SRyan Stone 
1070339bcfc7SRyan Stone 	nvlist_free(nvl, key);
1071339bcfc7SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
1072339bcfc7SRyan Stone 
1073339bcfc7SRyan Stone 	nvlist_destroy(nvl);
1074339bcfc7SRyan Stone }
1075339bcfc7SRyan Stone 
1076339bcfc7SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_null__single_null);
1077339bcfc7SRyan Stone ATF_TEST_CASE_BODY(nvlist_free_null__single_null)
1078339bcfc7SRyan Stone {
1079339bcfc7SRyan Stone 	nvlist_t *nvl;
1080339bcfc7SRyan Stone 	const char *key;
1081339bcfc7SRyan Stone 
1082339bcfc7SRyan Stone 	nvl = nvlist_create(0);
1083339bcfc7SRyan Stone 	key = "test";
1084339bcfc7SRyan Stone 	nvlist_add_null(nvl, key);
1085339bcfc7SRyan Stone 
1086339bcfc7SRyan Stone 	nvlist_free_null(nvl, key);
1087339bcfc7SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
1088339bcfc7SRyan Stone 
1089339bcfc7SRyan Stone 	nvlist_destroy(nvl);
1090339bcfc7SRyan Stone }
1091339bcfc7SRyan Stone 
1092339bcfc7SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_bool__single_bool);
1093339bcfc7SRyan Stone ATF_TEST_CASE_BODY(nvlist_free_bool__single_bool)
1094339bcfc7SRyan Stone {
1095339bcfc7SRyan Stone 	nvlist_t *nvl;
1096339bcfc7SRyan Stone 	const char *key;
1097339bcfc7SRyan Stone 
1098339bcfc7SRyan Stone 	nvl = nvlist_create(0);
1099339bcfc7SRyan Stone 	key = "test";
1100339bcfc7SRyan Stone 	nvlist_add_bool(nvl, key, true);
1101339bcfc7SRyan Stone 
1102339bcfc7SRyan Stone 	nvlist_free_bool(nvl, key);
1103339bcfc7SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
1104339bcfc7SRyan Stone 
1105339bcfc7SRyan Stone 	nvlist_destroy(nvl);
1106339bcfc7SRyan Stone }
1107339bcfc7SRyan Stone 
1108339bcfc7SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_number__single_number);
1109339bcfc7SRyan Stone ATF_TEST_CASE_BODY(nvlist_free_number__single_number)
1110339bcfc7SRyan Stone {
1111339bcfc7SRyan Stone 	nvlist_t *nvl;
1112339bcfc7SRyan Stone 	const char *key;
1113339bcfc7SRyan Stone 
1114339bcfc7SRyan Stone 	nvl = nvlist_create(0);
1115339bcfc7SRyan Stone 	key = "test";
1116339bcfc7SRyan Stone 	nvlist_add_number(nvl, key, 584);
1117339bcfc7SRyan Stone 
1118339bcfc7SRyan Stone 	nvlist_free_number(nvl, key);
1119339bcfc7SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
1120339bcfc7SRyan Stone 
1121339bcfc7SRyan Stone 	nvlist_destroy(nvl);
1122339bcfc7SRyan Stone }
1123339bcfc7SRyan Stone 
1124339bcfc7SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_string__single_string);
1125339bcfc7SRyan Stone ATF_TEST_CASE_BODY(nvlist_free_string__single_string)
1126339bcfc7SRyan Stone {
1127339bcfc7SRyan Stone 	nvlist_t *nvl;
1128339bcfc7SRyan Stone 	const char *key;
1129339bcfc7SRyan Stone 
1130339bcfc7SRyan Stone 	nvl = nvlist_create(0);
1131339bcfc7SRyan Stone 	key = "test";
1132339bcfc7SRyan Stone 	nvlist_add_string(nvl, key, "gjkfkjd");
1133339bcfc7SRyan Stone 
1134339bcfc7SRyan Stone 	nvlist_free_string(nvl, key);
1135339bcfc7SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
1136339bcfc7SRyan Stone 
1137339bcfc7SRyan Stone 	nvlist_destroy(nvl);
1138339bcfc7SRyan Stone }
1139339bcfc7SRyan Stone 
1140339bcfc7SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_nvlist__single_nvlist);
1141339bcfc7SRyan Stone ATF_TEST_CASE_BODY(nvlist_free_nvlist__single_nvlist)
1142339bcfc7SRyan Stone {
1143339bcfc7SRyan Stone 	nvlist_t *nvl;
1144339bcfc7SRyan Stone 	const char *key;
1145339bcfc7SRyan Stone 
1146339bcfc7SRyan Stone 	nvl = nvlist_create(0);
1147339bcfc7SRyan Stone 	key = "test";
1148339bcfc7SRyan Stone 	nvlist_add_nvlist(nvl, key, nvlist_create(0));
1149339bcfc7SRyan Stone 
1150339bcfc7SRyan Stone 	nvlist_free_nvlist(nvl, key);
1151339bcfc7SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
1152339bcfc7SRyan Stone 
1153339bcfc7SRyan Stone 	nvlist_destroy(nvl);
1154339bcfc7SRyan Stone }
1155339bcfc7SRyan Stone 
1156339bcfc7SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_binary__single_binary);
1157339bcfc7SRyan Stone ATF_TEST_CASE_BODY(nvlist_free_binary__single_binary)
1158339bcfc7SRyan Stone {
1159339bcfc7SRyan Stone 	nvlist_t *nvl;
1160339bcfc7SRyan Stone 	const char *key;
1161339bcfc7SRyan Stone 
1162339bcfc7SRyan Stone 	nvl = nvlist_create(0);
1163339bcfc7SRyan Stone 	key = "test";
1164339bcfc7SRyan Stone 	nvlist_add_binary(nvl, key, "jgjgfd", 6);
1165339bcfc7SRyan Stone 
1166339bcfc7SRyan Stone 	nvlist_free_binary(nvl, key);
1167339bcfc7SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
1168339bcfc7SRyan Stone 
1169339bcfc7SRyan Stone 	nvlist_destroy(nvl);
1170339bcfc7SRyan Stone }
1171339bcfc7SRyan Stone 
11723075c896SRyan Stone ATF_INIT_TEST_CASES(tp)
11733075c896SRyan Stone {
11743075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty);
11753075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert);
11763075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert);
11773075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert);
11783075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert);
11793075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert);
11803075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert);
11816e623ffdSRyan Stone 
11826e623ffdSRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_clone__empty_nvlist);
11836e623ffdSRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_clone__nonempty_nvlist);
11846e623ffdSRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_clone__nested_nvlist);
1185*a87e5162SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_clone__error_nvlist);
11866c721f82SRyan Stone 
11876c721f82SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_pack__empty_nvlist);
11886c721f82SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_pack__multiple_values);
1189*a87e5162SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_pack__error_nvlist);
11906c721f82SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_unpack__duplicate_key);
119171637d76SRyan Stone 
119271637d76SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_move_string__single_insert);
119371637d76SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__single_insert);
119471637d76SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__null_child);
119571637d76SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_move_binary__single_insert);
1196fad0a264SRyan Stone 
1197fad0a264SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__single_remove);
1198fad0a264SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__other_keys_unchanged);
1199fad0a264SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_number__single_remove);
1200fad0a264SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_number__other_keys_unchanged);
1201fad0a264SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_string__single_remove);
1202fad0a264SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_string__other_keys_unchanged);
1203fad0a264SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__single_remove);
1204fad0a264SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__other_keys_unchanged);
1205fad0a264SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__single_remove);
1206fad0a264SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__other_keys_unchanged);
1207339bcfc7SRyan Stone 
1208339bcfc7SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free__single_null);
1209339bcfc7SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free__single_bool);
1210339bcfc7SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free__single_number);
1211339bcfc7SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free__single_string);
1212339bcfc7SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free__single_nvlist);
1213339bcfc7SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free__single_binary);
1214339bcfc7SRyan Stone 
1215339bcfc7SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free_null__single_null);
1216339bcfc7SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free_bool__single_bool);
1217339bcfc7SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free_number__single_number);
1218339bcfc7SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free_string__single_string);
1219339bcfc7SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free_nvlist__single_nvlist);
1220339bcfc7SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free_binary__single_binary);
12213075c896SRyan Stone }
12223075c896SRyan Stone /*-
12233075c896SRyan Stone  * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
12243075c896SRyan Stone  * All rights reserved.
12253075c896SRyan Stone  *
12263075c896SRyan Stone  * Redistribution and use in source and binary forms, with or without
12273075c896SRyan Stone  * modification, are permitted provided that the following conditions
12283075c896SRyan Stone  * are met:
12293075c896SRyan Stone  * 1. Redistributions of source code must retain the above copyright
12303075c896SRyan Stone  *    notice, this list of conditions and the following disclaimer.
12313075c896SRyan Stone  * 2. Redistributions in binary form must reproduce the above copyright
12323075c896SRyan Stone  *    notice, this list of conditions and the following disclaimer in the
12333075c896SRyan Stone  *    documentation and/or other materials provided with the distribution.
12343075c896SRyan Stone  *
12353075c896SRyan Stone  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
12363075c896SRyan Stone  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
12373075c896SRyan Stone  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
12383075c896SRyan Stone  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
12393075c896SRyan Stone  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
12403075c896SRyan Stone  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
12413075c896SRyan Stone  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
12423075c896SRyan Stone  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
12433075c896SRyan Stone  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
12443075c896SRyan Stone  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
12453075c896SRyan Stone  * SUCH DAMAGE.
12463075c896SRyan Stone  */
12473075c896SRyan Stone 
12483075c896SRyan Stone #include <atf-c++.hpp>
12493075c896SRyan Stone #include <nv.h>
12503075c896SRyan Stone 
12513075c896SRyan Stone #include <errno.h>
12523075c896SRyan Stone /*
12533075c896SRyan Stone  * Test that a newly created nvlist has no errors, and is empty.
12543075c896SRyan Stone  */
12553075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty);
12563075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_create__is_empty)
12573075c896SRyan Stone {
12583075c896SRyan Stone 	nvlist_t *nvl;
12593075c896SRyan Stone 	int type;
12603075c896SRyan Stone 	void *it;
12613075c896SRyan Stone 
12623075c896SRyan Stone 	nvl = nvlist_create(0);
12633075c896SRyan Stone 
12643075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
12653075c896SRyan Stone 
12663075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
12673075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
12683075c896SRyan Stone 
12693075c896SRyan Stone 	it = NULL;
12703075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL);
12713075c896SRyan Stone 
12723075c896SRyan Stone 	nvlist_destroy(nvl);
12733075c896SRyan Stone }
12743075c896SRyan Stone 
12753075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert);
12763075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_null__single_insert)
12773075c896SRyan Stone {
12783075c896SRyan Stone 	nvlist_t *nvl;
12793075c896SRyan Stone 	void *it;
12803075c896SRyan Stone 	const char *key;
12813075c896SRyan Stone 	int type;
12823075c896SRyan Stone 
12833075c896SRyan Stone 	key = "key";
12843075c896SRyan Stone 	nvl = nvlist_create(0);
12853075c896SRyan Stone 
12863075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
12873075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
12883075c896SRyan Stone 
12893075c896SRyan Stone 	nvlist_add_null(nvl, key);
12903075c896SRyan Stone 
12913075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
12923075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
12933075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
12943075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(nvl, key));
12953075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_null(nvl, "key"));
12963075c896SRyan Stone 
12973075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
12983075c896SRyan Stone 	it = NULL;
12993075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
13003075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
13013075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
13023075c896SRyan Stone 
13033075c896SRyan Stone 	nvlist_destroy(nvl);
13043075c896SRyan Stone }
13053075c896SRyan Stone 
13063075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert);
13073075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert)
13083075c896SRyan Stone {
13093075c896SRyan Stone 	nvlist_t *nvl;
13103075c896SRyan Stone 	void *it;
13113075c896SRyan Stone 	const char *key;
13123075c896SRyan Stone 	int type;
13133075c896SRyan Stone 
13143075c896SRyan Stone 	key = "name";
13153075c896SRyan Stone 	nvl = nvlist_create(0);
13163075c896SRyan Stone 
13173075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
13183075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
13193075c896SRyan Stone 
13203075c896SRyan Stone 	nvlist_add_bool(nvl, key, true);
13213075c896SRyan Stone 
13223075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
13233075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
13243075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me"));
13253075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_bool(nvl, key));
13263075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e'));
13273075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true);
13283075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true);
13293075c896SRyan Stone 
13303075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
13313075c896SRyan Stone 	it = NULL;
13323075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
13333075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
13343075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
13353075c896SRyan Stone 
13363075c896SRyan Stone 	nvlist_destroy(nvl);
13373075c896SRyan Stone }
13383075c896SRyan Stone 
13393075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert);
13403075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_number__single_insert)
13413075c896SRyan Stone {
13423075c896SRyan Stone 	nvlist_t *nvl;
13433075c896SRyan Stone 	void *it;
13443075c896SRyan Stone 	const char *key;
13453075c896SRyan Stone 	uint64_t value;
13463075c896SRyan Stone 	int type;
13473075c896SRyan Stone 
13483075c896SRyan Stone 	key = "foo123";
13493075c896SRyan Stone 	value = 71965;
13503075c896SRyan Stone 	nvl = nvlist_create(0);
13513075c896SRyan Stone 
13523075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
13533075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
13543075c896SRyan Stone 
13553075c896SRyan Stone 	nvlist_add_number(nvl, key, value);
13563075c896SRyan Stone 
13573075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
13583075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
13593075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123));
13603075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_number(nvl, key));
13613075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key));
13623075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value);
13633075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value);
13643075c896SRyan Stone 
13653075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
13663075c896SRyan Stone 	it = NULL;
13673075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
13683075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
13693075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
13703075c896SRyan Stone 
13713075c896SRyan Stone 	nvlist_destroy(nvl);
13723075c896SRyan Stone }
13733075c896SRyan Stone 
13743075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert);
13753075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_string__single_insert)
13763075c896SRyan Stone {
13773075c896SRyan Stone 	nvlist_t *nvl;
13783075c896SRyan Stone 	void *it;
13793075c896SRyan Stone 	const char *key;
13803075c896SRyan Stone 	const char *value;
13813075c896SRyan Stone 	int type;
13823075c896SRyan Stone 
13833075c896SRyan Stone 	key = "test";
13843075c896SRyan Stone 	value = "fgjdkgjdk";
13853075c896SRyan Stone 	nvl = nvlist_create(0);
13863075c896SRyan Stone 
13873075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
13883075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
13893075c896SRyan Stone 
13903075c896SRyan Stone 	nvlist_add_string(nvl, key, value);
13913075c896SRyan Stone 
13923075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
13933075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
13943075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
13953075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_string(nvl, key));
13963075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key));
13973075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0);
13983075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0);
13993075c896SRyan Stone 
14003075c896SRyan Stone 	/* nvlist_add_* is required to clone the value, so check for that. */
14013075c896SRyan Stone 	ATF_REQUIRE(nvlist_get_string(nvl, key) != value);
14023075c896SRyan Stone 
14033075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
14043075c896SRyan Stone 	it = NULL;
14053075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
14063075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
14073075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
14083075c896SRyan Stone 
14093075c896SRyan Stone 	nvlist_destroy(nvl);
14103075c896SRyan Stone }
14113075c896SRyan Stone 
14123075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert);
14133075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert)
14143075c896SRyan Stone {
14153075c896SRyan Stone 	nvlist_t *nvl;
14163075c896SRyan Stone 	void *it;
14173075c896SRyan Stone 	const char *key, *subkey;
14183075c896SRyan Stone 	nvlist_t *sublist;
14193075c896SRyan Stone 	const nvlist_t *value;
14203075c896SRyan Stone 	int type;
14213075c896SRyan Stone 
14223075c896SRyan Stone 	key = "test";
14233075c896SRyan Stone 	subkey = "subkey";
14243075c896SRyan Stone 	sublist = nvlist_create(0);
14253075c896SRyan Stone 	nvl = nvlist_create(0);
14263075c896SRyan Stone 
14273075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
14283075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
14293075c896SRyan Stone 
14303075c896SRyan Stone 	nvlist_add_null(sublist, subkey);
14313075c896SRyan Stone 	nvlist_add_nvlist(nvl, key, sublist);
14323075c896SRyan Stone 
14333075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
14343075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
14353075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
14363075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
14373075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key));
14383075c896SRyan Stone 
14393075c896SRyan Stone 	value = nvlist_get_nvlist(nvl, key);
14403075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(value, subkey));
14413075c896SRyan Stone 
14423075c896SRyan Stone 	/* nvlist_add_* is required to clone the value, so check for that. */
14433075c896SRyan Stone 	ATF_REQUIRE(sublist != value);
14443075c896SRyan Stone 
14453075c896SRyan Stone 	value = nvlist_getf_nvlist(nvl, "%s", key);
14463075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(value, subkey));
14473075c896SRyan Stone 	ATF_REQUIRE(sublist != value);
14483075c896SRyan Stone 
14493075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
14503075c896SRyan Stone 	it = NULL;
14513075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
14523075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
14533075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
14543075c896SRyan Stone 
14553075c896SRyan Stone 	nvlist_destroy(sublist);
14563075c896SRyan Stone 	nvlist_destroy(nvl);
14573075c896SRyan Stone }
14583075c896SRyan Stone 
14593075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert);
14603075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert)
14613075c896SRyan Stone {
14623075c896SRyan Stone 	nvlist_t *nvl;
14633075c896SRyan Stone 	void *it;
14643075c896SRyan Stone 	const char *key;
14653075c896SRyan Stone 	void *value;
14663075c896SRyan Stone 	const void *ret_value;
14673075c896SRyan Stone 	size_t value_size, ret_size;
14683075c896SRyan Stone 	int type;
14693075c896SRyan Stone 
14703075c896SRyan Stone 	key = "binary";
14713075c896SRyan Stone 	value_size = 13;
14723075c896SRyan Stone 	value = malloc(value_size);
14733075c896SRyan Stone 	memset(value, 0xa5, value_size);
14743075c896SRyan Stone 	nvl = nvlist_create(0);
14753075c896SRyan Stone 
14763075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
14773075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
14783075c896SRyan Stone 
14793075c896SRyan Stone 	nvlist_add_binary(nvl, key, value, value_size);
14803075c896SRyan Stone 
14813075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
14823075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
14833075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
14843075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_binary(nvl, key));
14853075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key));
14863075c896SRyan Stone 
14873075c896SRyan Stone 	ret_value = nvlist_get_binary(nvl, key, &ret_size);
14883075c896SRyan Stone 	ATF_REQUIRE_EQ(value_size, ret_size);
14893075c896SRyan Stone 	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
14903075c896SRyan Stone 
14913075c896SRyan Stone 	/* nvlist_add_* is required to clone the value, so check for that. */
14923075c896SRyan Stone 	ATF_REQUIRE(value != ret_value);
14933075c896SRyan Stone 
14943075c896SRyan Stone 	ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key);
14953075c896SRyan Stone 	ATF_REQUIRE_EQ(value_size, ret_size);
14963075c896SRyan Stone 	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
14973075c896SRyan Stone 	ATF_REQUIRE(value != ret_value);
14983075c896SRyan Stone 
14993075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
15003075c896SRyan Stone 	it = NULL;
15013075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
15023075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
15033075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
15043075c896SRyan Stone 
15053075c896SRyan Stone 	nvlist_destroy(nvl);
15063075c896SRyan Stone 	free(value);
15073075c896SRyan Stone }
15083075c896SRyan Stone 
15093075c896SRyan Stone ATF_INIT_TEST_CASES(tp)
15103075c896SRyan Stone {
15113075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty);
15123075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert);
15133075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert);
15143075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert);
15153075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert);
15163075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert);
15173075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert);
15183075c896SRyan Stone }
15193075c896SRyan Stone /*-
15203075c896SRyan Stone  * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
15213075c896SRyan Stone  * All rights reserved.
15223075c896SRyan Stone  *
15233075c896SRyan Stone  * Redistribution and use in source and binary forms, with or without
15243075c896SRyan Stone  * modification, are permitted provided that the following conditions
15253075c896SRyan Stone  * are met:
15263075c896SRyan Stone  * 1. Redistributions of source code must retain the above copyright
15273075c896SRyan Stone  *    notice, this list of conditions and the following disclaimer.
15283075c896SRyan Stone  * 2. Redistributions in binary form must reproduce the above copyright
15293075c896SRyan Stone  *    notice, this list of conditions and the following disclaimer in the
15303075c896SRyan Stone  *    documentation and/or other materials provided with the distribution.
15313075c896SRyan Stone  *
15323075c896SRyan Stone  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15333075c896SRyan Stone  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15343075c896SRyan Stone  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
15353075c896SRyan Stone  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
15363075c896SRyan Stone  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
15373075c896SRyan Stone  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
15383075c896SRyan Stone  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
15393075c896SRyan Stone  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
15403075c896SRyan Stone  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
15413075c896SRyan Stone  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
15423075c896SRyan Stone  * SUCH DAMAGE.
15433075c896SRyan Stone  */
15443075c896SRyan Stone 
15453075c896SRyan Stone #include <atf-c++.hpp>
15463075c896SRyan Stone #include <nv.h>
15473075c896SRyan Stone 
15483075c896SRyan Stone #include <errno.h>
15493075c896SRyan Stone /*
15503075c896SRyan Stone  * Test that a newly created nvlist has no errors, and is empty.
15513075c896SRyan Stone  */
15523075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty);
15533075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_create__is_empty)
15543075c896SRyan Stone {
15553075c896SRyan Stone 	nvlist_t *nvl;
15563075c896SRyan Stone 	int type;
15573075c896SRyan Stone 	void *it;
15583075c896SRyan Stone 
15593075c896SRyan Stone 	nvl = nvlist_create(0);
15603075c896SRyan Stone 
15613075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
15623075c896SRyan Stone 
15633075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
15643075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
15653075c896SRyan Stone 
15663075c896SRyan Stone 	it = NULL;
15673075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL);
15683075c896SRyan Stone 
15693075c896SRyan Stone 	nvlist_destroy(nvl);
15703075c896SRyan Stone }
15713075c896SRyan Stone 
15723075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert);
15733075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_null__single_insert)
15743075c896SRyan Stone {
15753075c896SRyan Stone 	nvlist_t *nvl;
15763075c896SRyan Stone 	void *it;
15773075c896SRyan Stone 	const char *key;
15783075c896SRyan Stone 	int type;
15793075c896SRyan Stone 
15803075c896SRyan Stone 	key = "key";
15813075c896SRyan Stone 	nvl = nvlist_create(0);
15823075c896SRyan Stone 
15833075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
15843075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
15853075c896SRyan Stone 
15863075c896SRyan Stone 	nvlist_add_null(nvl, key);
15873075c896SRyan Stone 
15883075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
15893075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
15903075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
15913075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(nvl, key));
15923075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_null(nvl, "key"));
15933075c896SRyan Stone 
15943075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
15953075c896SRyan Stone 	it = NULL;
15963075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
15973075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
15983075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
15993075c896SRyan Stone 
16003075c896SRyan Stone 	nvlist_destroy(nvl);
16013075c896SRyan Stone }
16023075c896SRyan Stone 
16033075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert);
16043075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert)
16053075c896SRyan Stone {
16063075c896SRyan Stone 	nvlist_t *nvl;
16073075c896SRyan Stone 	void *it;
16083075c896SRyan Stone 	const char *key;
16093075c896SRyan Stone 	int type;
16103075c896SRyan Stone 
16113075c896SRyan Stone 	key = "name";
16123075c896SRyan Stone 	nvl = nvlist_create(0);
16133075c896SRyan Stone 
16143075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
16153075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
16163075c896SRyan Stone 
16173075c896SRyan Stone 	nvlist_add_bool(nvl, key, true);
16183075c896SRyan Stone 
16193075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
16203075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
16213075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me"));
16223075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_bool(nvl, key));
16233075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e'));
16243075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true);
16253075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true);
16263075c896SRyan Stone 
16273075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
16283075c896SRyan Stone 	it = NULL;
16293075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
16303075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
16313075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
16323075c896SRyan Stone 
16333075c896SRyan Stone 	nvlist_destroy(nvl);
16343075c896SRyan Stone }
16353075c896SRyan Stone 
16363075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert);
16373075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_number__single_insert)
16383075c896SRyan Stone {
16393075c896SRyan Stone 	nvlist_t *nvl;
16403075c896SRyan Stone 	void *it;
16413075c896SRyan Stone 	const char *key;
16423075c896SRyan Stone 	uint64_t value;
16433075c896SRyan Stone 	int type;
16443075c896SRyan Stone 
16453075c896SRyan Stone 	key = "foo123";
16463075c896SRyan Stone 	value = 71965;
16473075c896SRyan Stone 	nvl = nvlist_create(0);
16483075c896SRyan Stone 
16493075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
16503075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
16513075c896SRyan Stone 
16523075c896SRyan Stone 	nvlist_add_number(nvl, key, value);
16533075c896SRyan Stone 
16543075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
16553075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
16563075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123));
16573075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_number(nvl, key));
16583075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key));
16593075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value);
16603075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value);
16613075c896SRyan Stone 
16623075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
16633075c896SRyan Stone 	it = NULL;
16643075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
16653075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
16663075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
16673075c896SRyan Stone 
16683075c896SRyan Stone 	nvlist_destroy(nvl);
16693075c896SRyan Stone }
16703075c896SRyan Stone 
16713075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert);
16723075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_string__single_insert)
16733075c896SRyan Stone {
16743075c896SRyan Stone 	nvlist_t *nvl;
16753075c896SRyan Stone 	void *it;
16763075c896SRyan Stone 	const char *key;
16773075c896SRyan Stone 	const char *value;
16783075c896SRyan Stone 	int type;
16793075c896SRyan Stone 
16803075c896SRyan Stone 	key = "test";
16813075c896SRyan Stone 	value = "fgjdkgjdk";
16823075c896SRyan Stone 	nvl = nvlist_create(0);
16833075c896SRyan Stone 
16843075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
16853075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
16863075c896SRyan Stone 
16873075c896SRyan Stone 	nvlist_add_string(nvl, key, value);
16883075c896SRyan Stone 
16893075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
16903075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
16913075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
16923075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_string(nvl, key));
16933075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key));
16943075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0);
16953075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0);
16963075c896SRyan Stone 
16973075c896SRyan Stone 	/* nvlist_add_* is required to clone the value, so check for that. */
16983075c896SRyan Stone 	ATF_REQUIRE(nvlist_get_string(nvl, key) != value);
16993075c896SRyan Stone 
17003075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
17013075c896SRyan Stone 	it = NULL;
17023075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
17033075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
17043075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
17053075c896SRyan Stone 
17063075c896SRyan Stone 	nvlist_destroy(nvl);
17073075c896SRyan Stone }
17083075c896SRyan Stone 
17093075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert);
17103075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert)
17113075c896SRyan Stone {
17123075c896SRyan Stone 	nvlist_t *nvl;
17133075c896SRyan Stone 	void *it;
17143075c896SRyan Stone 	const char *key, *subkey;
17153075c896SRyan Stone 	nvlist_t *sublist;
17163075c896SRyan Stone 	const nvlist_t *value;
17173075c896SRyan Stone 	int type;
17183075c896SRyan Stone 
17193075c896SRyan Stone 	key = "test";
17203075c896SRyan Stone 	subkey = "subkey";
17213075c896SRyan Stone 	sublist = nvlist_create(0);
17223075c896SRyan Stone 	nvl = nvlist_create(0);
17233075c896SRyan Stone 
17243075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
17253075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
17263075c896SRyan Stone 
17273075c896SRyan Stone 	nvlist_add_null(sublist, subkey);
17283075c896SRyan Stone 	nvlist_add_nvlist(nvl, key, sublist);
17293075c896SRyan Stone 
17303075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
17313075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
17323075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
17333075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
17343075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key));
17353075c896SRyan Stone 
17363075c896SRyan Stone 	value = nvlist_get_nvlist(nvl, key);
17373075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(value, subkey));
17383075c896SRyan Stone 
17393075c896SRyan Stone 	/* nvlist_add_* is required to clone the value, so check for that. */
17403075c896SRyan Stone 	ATF_REQUIRE(sublist != value);
17413075c896SRyan Stone 
17423075c896SRyan Stone 	value = nvlist_getf_nvlist(nvl, "%s", key);
17433075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(value, subkey));
17443075c896SRyan Stone 	ATF_REQUIRE(sublist != value);
17453075c896SRyan Stone 
17463075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
17473075c896SRyan Stone 	it = NULL;
17483075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
17493075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
17503075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
17513075c896SRyan Stone 
17523075c896SRyan Stone 	nvlist_destroy(sublist);
17533075c896SRyan Stone 	nvlist_destroy(nvl);
17543075c896SRyan Stone }
17553075c896SRyan Stone 
17563075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert);
17573075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert)
17583075c896SRyan Stone {
17593075c896SRyan Stone 	nvlist_t *nvl;
17603075c896SRyan Stone 	void *it;
17613075c896SRyan Stone 	const char *key;
17623075c896SRyan Stone 	void *value;
17633075c896SRyan Stone 	const void *ret_value;
17643075c896SRyan Stone 	size_t value_size, ret_size;
17653075c896SRyan Stone 	int type;
17663075c896SRyan Stone 
17673075c896SRyan Stone 	key = "binary";
17683075c896SRyan Stone 	value_size = 13;
17693075c896SRyan Stone 	value = malloc(value_size);
17703075c896SRyan Stone 	memset(value, 0xa5, value_size);
17713075c896SRyan Stone 	nvl = nvlist_create(0);
17723075c896SRyan Stone 
17733075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
17743075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
17753075c896SRyan Stone 
17763075c896SRyan Stone 	nvlist_add_binary(nvl, key, value, value_size);
17773075c896SRyan Stone 
17783075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
17793075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
17803075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
17813075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_binary(nvl, key));
17823075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key));
17833075c896SRyan Stone 
17843075c896SRyan Stone 	ret_value = nvlist_get_binary(nvl, key, &ret_size);
17853075c896SRyan Stone 	ATF_REQUIRE_EQ(value_size, ret_size);
17863075c896SRyan Stone 	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
17873075c896SRyan Stone 
17883075c896SRyan Stone 	/* nvlist_add_* is required to clone the value, so check for that. */
17893075c896SRyan Stone 	ATF_REQUIRE(value != ret_value);
17903075c896SRyan Stone 
17913075c896SRyan Stone 	ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key);
17923075c896SRyan Stone 	ATF_REQUIRE_EQ(value_size, ret_size);
17933075c896SRyan Stone 	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
17943075c896SRyan Stone 	ATF_REQUIRE(value != ret_value);
17953075c896SRyan Stone 
17963075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
17973075c896SRyan Stone 	it = NULL;
17983075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
17993075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
18003075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
18013075c896SRyan Stone 
18023075c896SRyan Stone 	nvlist_destroy(nvl);
18033075c896SRyan Stone 	free(value);
18043075c896SRyan Stone }
18053075c896SRyan Stone 
18063075c896SRyan Stone ATF_INIT_TEST_CASES(tp)
18073075c896SRyan Stone {
18083075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty);
18093075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert);
18103075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert);
18113075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert);
18123075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert);
18133075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert);
18143075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert);
18153075c896SRyan Stone }
18163075c896SRyan Stone /*-
18173075c896SRyan Stone  * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
18183075c896SRyan Stone  * All rights reserved.
18193075c896SRyan Stone  *
18203075c896SRyan Stone  * Redistribution and use in source and binary forms, with or without
18213075c896SRyan Stone  * modification, are permitted provided that the following conditions
18223075c896SRyan Stone  * are met:
18233075c896SRyan Stone  * 1. Redistributions of source code must retain the above copyright
18243075c896SRyan Stone  *    notice, this list of conditions and the following disclaimer.
18253075c896SRyan Stone  * 2. Redistributions in binary form must reproduce the above copyright
18263075c896SRyan Stone  *    notice, this list of conditions and the following disclaimer in the
18273075c896SRyan Stone  *    documentation and/or other materials provided with the distribution.
18283075c896SRyan Stone  *
18293075c896SRyan Stone  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18303075c896SRyan Stone  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18313075c896SRyan Stone  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18323075c896SRyan Stone  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18333075c896SRyan Stone  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18343075c896SRyan Stone  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
18353075c896SRyan Stone  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
18363075c896SRyan Stone  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
18373075c896SRyan Stone  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
18383075c896SRyan Stone  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
18393075c896SRyan Stone  * SUCH DAMAGE.
18403075c896SRyan Stone  */
18413075c896SRyan Stone 
18423075c896SRyan Stone #include <atf-c++.hpp>
18433075c896SRyan Stone #include <nv.h>
18443075c896SRyan Stone 
18453075c896SRyan Stone #include <errno.h>
18463075c896SRyan Stone #include <limits>
18473075c896SRyan Stone #include <set>
18483075c896SRyan Stone #include <sstream>
18493075c896SRyan Stone #include <string>
18503075c896SRyan Stone 
18513075c896SRyan Stone /*
18523075c896SRyan Stone  * Test that a newly created nvlist has no errors, and is empty.
18533075c896SRyan Stone  */
18543075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty);
18553075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_create__is_empty)
18563075c896SRyan Stone {
18573075c896SRyan Stone 	nvlist_t *nvl;
18583075c896SRyan Stone 	int type;
18593075c896SRyan Stone 	void *it;
18603075c896SRyan Stone 
18613075c896SRyan Stone 	nvl = nvlist_create(0);
18623075c896SRyan Stone 
18633075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
18643075c896SRyan Stone 
18653075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
18663075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
18673075c896SRyan Stone 
18683075c896SRyan Stone 	it = NULL;
18693075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL);
18703075c896SRyan Stone 
18713075c896SRyan Stone 	nvlist_destroy(nvl);
18723075c896SRyan Stone }
18733075c896SRyan Stone 
18743075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert);
18753075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_null__single_insert)
18763075c896SRyan Stone {
18773075c896SRyan Stone 	nvlist_t *nvl;
18783075c896SRyan Stone 	void *it;
18793075c896SRyan Stone 	const char *key;
18803075c896SRyan Stone 	int type;
18813075c896SRyan Stone 
18823075c896SRyan Stone 	key = "key";
18833075c896SRyan Stone 	nvl = nvlist_create(0);
18843075c896SRyan Stone 
18853075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
18863075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
18873075c896SRyan Stone 
18883075c896SRyan Stone 	nvlist_add_null(nvl, key);
18893075c896SRyan Stone 
18903075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
18913075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
18923075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
18933075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(nvl, key));
18943075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_null(nvl, "key"));
18953075c896SRyan Stone 
18963075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
18973075c896SRyan Stone 	it = NULL;
18983075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
18993075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
19003075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
19013075c896SRyan Stone 
19023075c896SRyan Stone 	nvlist_destroy(nvl);
19033075c896SRyan Stone }
19043075c896SRyan Stone 
19053075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert);
19063075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert)
19073075c896SRyan Stone {
19083075c896SRyan Stone 	nvlist_t *nvl;
19093075c896SRyan Stone 	void *it;
19103075c896SRyan Stone 	const char *key;
19113075c896SRyan Stone 	int type;
19123075c896SRyan Stone 
19133075c896SRyan Stone 	key = "name";
19143075c896SRyan Stone 	nvl = nvlist_create(0);
19153075c896SRyan Stone 
19163075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
19173075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
19183075c896SRyan Stone 
19193075c896SRyan Stone 	nvlist_add_bool(nvl, key, true);
19203075c896SRyan Stone 
19213075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
19223075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
19233075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me"));
19243075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_bool(nvl, key));
19253075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e'));
19263075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true);
19273075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true);
19283075c896SRyan Stone 
19293075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
19303075c896SRyan Stone 	it = NULL;
19313075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
19323075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
19333075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
19343075c896SRyan Stone 
19353075c896SRyan Stone 	nvlist_destroy(nvl);
19363075c896SRyan Stone }
19373075c896SRyan Stone 
19383075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert);
19393075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_number__single_insert)
19403075c896SRyan Stone {
19413075c896SRyan Stone 	nvlist_t *nvl;
19423075c896SRyan Stone 	void *it;
19433075c896SRyan Stone 	const char *key;
19443075c896SRyan Stone 	uint64_t value;
19453075c896SRyan Stone 	int type;
19463075c896SRyan Stone 
19473075c896SRyan Stone 	key = "foo123";
19483075c896SRyan Stone 	value = 71965;
19493075c896SRyan Stone 	nvl = nvlist_create(0);
19503075c896SRyan Stone 
19513075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
19523075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
19533075c896SRyan Stone 
19543075c896SRyan Stone 	nvlist_add_number(nvl, key, value);
19553075c896SRyan Stone 
19563075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
19573075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
19583075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123));
19593075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_number(nvl, key));
19603075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key));
19613075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value);
19623075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value);
19633075c896SRyan Stone 
19643075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
19653075c896SRyan Stone 	it = NULL;
19663075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
19673075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
19683075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
19693075c896SRyan Stone 
19703075c896SRyan Stone 	nvlist_destroy(nvl);
19713075c896SRyan Stone }
19723075c896SRyan Stone 
19733075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert);
19743075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_string__single_insert)
19753075c896SRyan Stone {
19763075c896SRyan Stone 	nvlist_t *nvl;
19773075c896SRyan Stone 	void *it;
19783075c896SRyan Stone 	const char *key;
19793075c896SRyan Stone 	const char *value;
19803075c896SRyan Stone 	int type;
19813075c896SRyan Stone 
19823075c896SRyan Stone 	key = "test";
19833075c896SRyan Stone 	value = "fgjdkgjdk";
19843075c896SRyan Stone 	nvl = nvlist_create(0);
19853075c896SRyan Stone 
19863075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
19873075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
19883075c896SRyan Stone 
19893075c896SRyan Stone 	nvlist_add_string(nvl, key, value);
19903075c896SRyan Stone 
19913075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
19923075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
19933075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
19943075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_string(nvl, key));
19953075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key));
19963075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0);
19973075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0);
19983075c896SRyan Stone 
19993075c896SRyan Stone 	/* nvlist_add_* is required to clone the value, so check for that. */
20003075c896SRyan Stone 	ATF_REQUIRE(nvlist_get_string(nvl, key) != value);
20013075c896SRyan Stone 
20023075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
20033075c896SRyan Stone 	it = NULL;
20043075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
20053075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
20063075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
20073075c896SRyan Stone 
20083075c896SRyan Stone 	nvlist_destroy(nvl);
20093075c896SRyan Stone }
20103075c896SRyan Stone 
20113075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert);
20123075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert)
20133075c896SRyan Stone {
20143075c896SRyan Stone 	nvlist_t *nvl;
20153075c896SRyan Stone 	void *it;
20163075c896SRyan Stone 	const char *key, *subkey;
20173075c896SRyan Stone 	nvlist_t *sublist;
20183075c896SRyan Stone 	const nvlist_t *value;
20193075c896SRyan Stone 	int type;
20203075c896SRyan Stone 
20213075c896SRyan Stone 	key = "test";
20223075c896SRyan Stone 	subkey = "subkey";
20233075c896SRyan Stone 	sublist = nvlist_create(0);
20243075c896SRyan Stone 	nvl = nvlist_create(0);
20253075c896SRyan Stone 
20263075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
20273075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
20283075c896SRyan Stone 
20293075c896SRyan Stone 	nvlist_add_null(sublist, subkey);
20303075c896SRyan Stone 	nvlist_add_nvlist(nvl, key, sublist);
20313075c896SRyan Stone 
20323075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
20333075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
20343075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
20353075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
20363075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key));
20373075c896SRyan Stone 
20383075c896SRyan Stone 	value = nvlist_get_nvlist(nvl, key);
20393075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(value, subkey));
20403075c896SRyan Stone 
20413075c896SRyan Stone 	/* nvlist_add_* is required to clone the value, so check for that. */
20423075c896SRyan Stone 	ATF_REQUIRE(sublist != value);
20433075c896SRyan Stone 
20443075c896SRyan Stone 	value = nvlist_getf_nvlist(nvl, "%s", key);
20453075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(value, subkey));
20463075c896SRyan Stone 	ATF_REQUIRE(sublist != value);
20473075c896SRyan Stone 
20483075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
20493075c896SRyan Stone 	it = NULL;
20503075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
20513075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
20523075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
20533075c896SRyan Stone 
20543075c896SRyan Stone 	nvlist_destroy(sublist);
20553075c896SRyan Stone 	nvlist_destroy(nvl);
20563075c896SRyan Stone }
20573075c896SRyan Stone 
20583075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert);
20593075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert)
20603075c896SRyan Stone {
20613075c896SRyan Stone 	nvlist_t *nvl;
20623075c896SRyan Stone 	void *it;
20633075c896SRyan Stone 	const char *key;
20643075c896SRyan Stone 	void *value;
20653075c896SRyan Stone 	const void *ret_value;
20663075c896SRyan Stone 	size_t value_size, ret_size;
20673075c896SRyan Stone 	int type;
20683075c896SRyan Stone 
20693075c896SRyan Stone 	key = "binary";
20703075c896SRyan Stone 	value_size = 13;
20713075c896SRyan Stone 	value = malloc(value_size);
20723075c896SRyan Stone 	memset(value, 0xa5, value_size);
20733075c896SRyan Stone 	nvl = nvlist_create(0);
20743075c896SRyan Stone 
20753075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
20763075c896SRyan Stone 	ATF_REQUIRE(!nvlist_exists(nvl, key));
20773075c896SRyan Stone 
20783075c896SRyan Stone 	nvlist_add_binary(nvl, key, value, value_size);
20793075c896SRyan Stone 
20803075c896SRyan Stone 	ATF_REQUIRE(!nvlist_empty(nvl));
20813075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists(nvl, key));
20823075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
20833075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_binary(nvl, key));
20843075c896SRyan Stone 	ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key));
20853075c896SRyan Stone 
20863075c896SRyan Stone 	ret_value = nvlist_get_binary(nvl, key, &ret_size);
20873075c896SRyan Stone 	ATF_REQUIRE_EQ(value_size, ret_size);
20883075c896SRyan Stone 	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
20893075c896SRyan Stone 
20903075c896SRyan Stone 	/* nvlist_add_* is required to clone the value, so check for that. */
20913075c896SRyan Stone 	ATF_REQUIRE(value != ret_value);
20923075c896SRyan Stone 
20933075c896SRyan Stone 	ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key);
20943075c896SRyan Stone 	ATF_REQUIRE_EQ(value_size, ret_size);
20953075c896SRyan Stone 	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
20963075c896SRyan Stone 	ATF_REQUIRE(value != ret_value);
20973075c896SRyan Stone 
20983075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
20993075c896SRyan Stone 	it = NULL;
21003075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
21013075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
21023075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL);
21033075c896SRyan Stone 
21043075c896SRyan Stone 	nvlist_destroy(nvl);
21053075c896SRyan Stone 	free(value);
21063075c896SRyan Stone }
21073075c896SRyan Stone 
21083075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__empty_nvlist);
21093075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_clone__empty_nvlist)
21103075c896SRyan Stone {
21113075c896SRyan Stone 	nvlist_t *nvl, *clone;
21123075c896SRyan Stone 
21133075c896SRyan Stone 	nvl = nvlist_create(0);
21143075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
21153075c896SRyan Stone 
21163075c896SRyan Stone 	clone = nvlist_clone(nvl);
21173075c896SRyan Stone 	ATF_REQUIRE(clone != NULL);
21183075c896SRyan Stone 	ATF_REQUIRE(clone != nvl);
21193075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(clone));
21203075c896SRyan Stone 
21213075c896SRyan Stone 	nvlist_destroy(clone);
21223075c896SRyan Stone 	nvlist_destroy(nvl);
21233075c896SRyan Stone }
21243075c896SRyan Stone 
21253075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nonempty_nvlist);
21263075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_clone__nonempty_nvlist)
21273075c896SRyan Stone {
21283075c896SRyan Stone 	nvlist_t *nvl, *clone;
21293075c896SRyan Stone 	const char *key;
21303075c896SRyan Stone 	void *it;
21313075c896SRyan Stone 	uint64_t value;
21323075c896SRyan Stone 	int type;
21333075c896SRyan Stone 
21343075c896SRyan Stone 	nvl = nvlist_create(0);
21353075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
21363075c896SRyan Stone 
21373075c896SRyan Stone 	key = "testkey";
21383075c896SRyan Stone 	value = 684874;
21393075c896SRyan Stone 	nvlist_add_number(nvl, key, value);
21403075c896SRyan Stone 
21413075c896SRyan Stone 	clone = nvlist_clone(nvl);
21423075c896SRyan Stone 	ATF_REQUIRE(clone != NULL);
21433075c896SRyan Stone 	ATF_REQUIRE(clone != nvl);
21443075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_number(clone, key));
21453075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_number(clone, key), value);
21463075c896SRyan Stone 
21473075c896SRyan Stone 	/* Iterate over the nvlist; ensure that it has only our one key. */
21483075c896SRyan Stone 	it = NULL;
21493075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(clone, &type, &it), key), 0);
21503075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
21513075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(clone, &type, &it), NULL);
21523075c896SRyan Stone 
21533075c896SRyan Stone 	nvlist_destroy(clone);
21543075c896SRyan Stone 	nvlist_destroy(nvl);
21553075c896SRyan Stone }
21563075c896SRyan Stone 
21573075c896SRyan Stone static const char * const test_subnvlist_key = "nvlist";
21583075c896SRyan Stone 
21593075c896SRyan Stone static const char * const test_string_key = "string";
21603075c896SRyan Stone static const char * const test_string_val = "59525";
21613075c896SRyan Stone 
21623075c896SRyan Stone static nvlist_t*
21633075c896SRyan Stone create_test_nvlist(void)
21643075c896SRyan Stone {
21653075c896SRyan Stone 	nvlist_t *nvl, *sublist;
21663075c896SRyan Stone 
21673075c896SRyan Stone 	nvl = nvlist_create(0);
21683075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
21693075c896SRyan Stone 
21703075c896SRyan Stone 	sublist = nvlist_create(0);
21713075c896SRyan Stone 	ATF_REQUIRE(sublist != NULL);
21723075c896SRyan Stone 
21733075c896SRyan Stone 	nvlist_add_string(sublist, test_string_key, test_string_val);
21743075c896SRyan Stone 	nvlist_move_nvlist(nvl, test_subnvlist_key, sublist);
21753075c896SRyan Stone 
21763075c896SRyan Stone 	return (nvl);
21773075c896SRyan Stone }
21783075c896SRyan Stone 
21793075c896SRyan Stone static void
21803075c896SRyan Stone verify_test_nvlist(const nvlist_t *nvl)
21813075c896SRyan Stone {
21823075c896SRyan Stone 	void *it;
21833075c896SRyan Stone 	const nvlist_t *value;
21843075c896SRyan Stone 	int type;
21853075c896SRyan Stone 
21863075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_nvlist(nvl, test_subnvlist_key));
21873075c896SRyan Stone 
21883075c896SRyan Stone 	value = nvlist_get_nvlist(nvl, test_subnvlist_key);
21893075c896SRyan Stone 
21903075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_string(value, test_string_key));
21913075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(value, test_string_key), test_string_val), 0);
21923075c896SRyan Stone 	ATF_REQUIRE(nvlist_get_string(value, test_string_key) != test_string_val);
21933075c896SRyan Stone 
21943075c896SRyan Stone 	/* Iterate over both nvlists; ensure that each has only the one key. */
21953075c896SRyan Stone 	it = NULL;
21963075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(value, &type, &it),
21973075c896SRyan Stone 	    test_string_key), 0);
21983075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
21993075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(value, &type, &it), NULL);
22003075c896SRyan Stone 
22013075c896SRyan Stone 	it = NULL;
22023075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it),
22033075c896SRyan Stone 	    test_subnvlist_key), 0);
22043075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
22053075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL);
22063075c896SRyan Stone }
22073075c896SRyan Stone 
22083075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nested_nvlist);
22093075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_clone__nested_nvlist)
22103075c896SRyan Stone {
22113075c896SRyan Stone 	nvlist_t *nvl, *clone;
22123075c896SRyan Stone 
22133075c896SRyan Stone 	nvl = create_test_nvlist();
22143075c896SRyan Stone 	clone = nvlist_clone(nvl);
22153075c896SRyan Stone 
22163075c896SRyan Stone 	ATF_REQUIRE(clone != NULL);
22173075c896SRyan Stone 	ATF_REQUIRE(clone != nvl);
22183075c896SRyan Stone 	verify_test_nvlist(clone);
22193075c896SRyan Stone 
22203075c896SRyan Stone 	nvlist_destroy(clone);
22213075c896SRyan Stone 	nvlist_destroy(nvl);
22223075c896SRyan Stone }
22233075c896SRyan Stone 
22243075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__empty_nvlist);
22253075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_pack__empty_nvlist)
22263075c896SRyan Stone {
22273075c896SRyan Stone 	nvlist_t *nvl, *unpacked;
22283075c896SRyan Stone 	void *packed;
22293075c896SRyan Stone 	size_t packed_size;
22303075c896SRyan Stone 
22313075c896SRyan Stone 	nvl = nvlist_create(0);
22323075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
22333075c896SRyan Stone 
22343075c896SRyan Stone 	packed = nvlist_pack(nvl, &packed_size);
22353075c896SRyan Stone 	ATF_REQUIRE(packed != NULL);
22363075c896SRyan Stone 
22373075c896SRyan Stone 	unpacked = nvlist_unpack(packed, packed_size);
22383075c896SRyan Stone 	ATF_REQUIRE(unpacked != NULL);
22393075c896SRyan Stone 	ATF_REQUIRE(unpacked != nvl);
22403075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(unpacked));
22413075c896SRyan Stone 
22423075c896SRyan Stone 	nvlist_destroy(unpacked);
22433075c896SRyan Stone 	nvlist_destroy(nvl);
22443075c896SRyan Stone 	free(packed);
22453075c896SRyan Stone }
22463075c896SRyan Stone 
22473075c896SRyan Stone static void
22483075c896SRyan Stone verify_null(const nvlist_t *nvl, int type)
22493075c896SRyan Stone {
22503075c896SRyan Stone 
22513075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
22523075c896SRyan Stone }
22533075c896SRyan Stone 
22543075c896SRyan Stone static void
22553075c896SRyan Stone verify_number(const nvlist_t *nvl, const char *name, int type, uint64_t value)
22563075c896SRyan Stone {
22573075c896SRyan Stone 
22583075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
22593075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_number(nvl, name), value);
22603075c896SRyan Stone }
22613075c896SRyan Stone 
22623075c896SRyan Stone static void
22633075c896SRyan Stone verify_string(const nvlist_t *nvl, const char *name, int type,
22643075c896SRyan Stone     const char * value)
22653075c896SRyan Stone {
22663075c896SRyan Stone 
22673075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
22683075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, name), value), 0);
22693075c896SRyan Stone }
22703075c896SRyan Stone 
22713075c896SRyan Stone static void
22723075c896SRyan Stone verify_nvlist(const nvlist_t *nvl, const char *name, int type)
22733075c896SRyan Stone {
22743075c896SRyan Stone 
22753075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
22763075c896SRyan Stone 	verify_test_nvlist(nvlist_get_nvlist(nvl, name));
22773075c896SRyan Stone }
22783075c896SRyan Stone 
22793075c896SRyan Stone static void
22803075c896SRyan Stone verify_binary(const nvlist_t *nvl, const char *name, int type,
22813075c896SRyan Stone     const void * value, size_t size)
22823075c896SRyan Stone {
22833075c896SRyan Stone 	const void *actual_value;
22843075c896SRyan Stone 	size_t actual_size;
22853075c896SRyan Stone 
22863075c896SRyan Stone 	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
22873075c896SRyan Stone 	actual_value = nvlist_get_binary(nvl, name, &actual_size);
22883075c896SRyan Stone 	ATF_REQUIRE_EQ(size, actual_size);
22893075c896SRyan Stone 	ATF_REQUIRE_EQ(memcmp(value, actual_value, size), 0);
22903075c896SRyan Stone }
22913075c896SRyan Stone 
22923075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__multiple_values);
22933075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_pack__multiple_values)
22943075c896SRyan Stone {
22953075c896SRyan Stone 	std::ostringstream msg;
22963075c896SRyan Stone 	std::set<std::string> keys_seen;
22973075c896SRyan Stone 	nvlist_t *nvl, *unpacked, *nvvalue;
22983075c896SRyan Stone 	const char *nullkey, *numkey, *strkey, *nvkey, *binkey, *name;
22993075c896SRyan Stone 	int numvalue;
23003075c896SRyan Stone 	const char * strvalue;
23013075c896SRyan Stone 	void *binvalue, *packed, *it;
23023075c896SRyan Stone 	size_t binsize, packed_size;
23033075c896SRyan Stone 	int type;
23043075c896SRyan Stone 
23053075c896SRyan Stone 	nvl = nvlist_create(0);
23063075c896SRyan Stone 
23073075c896SRyan Stone 	nullkey = "null";
23083075c896SRyan Stone 	nvlist_add_null(nvl, nullkey);
23093075c896SRyan Stone 
23103075c896SRyan Stone 	numkey = "number";
23113075c896SRyan Stone 	numvalue = 939853984;
23123075c896SRyan Stone 	nvlist_add_number(nvl, numkey, numvalue);
23133075c896SRyan Stone 
23143075c896SRyan Stone 	strkey = "string";
23153075c896SRyan Stone 	strvalue = "jfieutijf";
23163075c896SRyan Stone 	nvlist_add_string(nvl, strkey, strvalue);
23173075c896SRyan Stone 
23183075c896SRyan Stone 	nvkey = "nvlist";
23193075c896SRyan Stone 	nvvalue = create_test_nvlist();
23203075c896SRyan Stone 	nvlist_move_nvlist(nvl, nvkey, nvvalue);
23213075c896SRyan Stone 
23223075c896SRyan Stone 	binkey = "binary";
23233075c896SRyan Stone 	binsize = 4;
23243075c896SRyan Stone 	binvalue = malloc(binsize);
23253075c896SRyan Stone 	memset(binvalue, 'b', binsize);
23263075c896SRyan Stone 	nvlist_move_binary(nvl, binkey, binvalue, binsize);
23273075c896SRyan Stone 
23283075c896SRyan Stone 	packed = nvlist_pack(nvl, &packed_size);
23293075c896SRyan Stone 	ATF_REQUIRE(packed != NULL);
23303075c896SRyan Stone 
23313075c896SRyan Stone 	unpacked = nvlist_unpack(packed, packed_size);
23323075c896SRyan Stone 	ATF_REQUIRE(unpacked != 0);
23333075c896SRyan Stone 
23343075c896SRyan Stone 	it = NULL;
23353075c896SRyan Stone 	while ((name = nvlist_next(unpacked, &type, &it)) != NULL) {
23363075c896SRyan Stone 		/* Ensure that we see every key only once. */
23373075c896SRyan Stone 		ATF_REQUIRE_EQ(keys_seen.count(name), 0);
23383075c896SRyan Stone 
23393075c896SRyan Stone 		if (strcmp(name, nullkey) == 0)
23403075c896SRyan Stone 			verify_null(unpacked, type);
23413075c896SRyan Stone 		else if (strcmp(name, numkey) == 0)
23423075c896SRyan Stone 			verify_number(unpacked, name, type, numvalue);
23433075c896SRyan Stone 		else if (strcmp(name, strkey) == 0)
23443075c896SRyan Stone 			verify_string(unpacked, name, type, strvalue);
23453075c896SRyan Stone 		else if (strcmp(name, nvkey) == 0)
23463075c896SRyan Stone 			verify_nvlist(unpacked, name, type);
23473075c896SRyan Stone 		else if (strcmp(name, binkey) == 0)
23483075c896SRyan Stone 			verify_binary(unpacked, name, type, binvalue, binsize);
23493075c896SRyan Stone 		else {
23503075c896SRyan Stone 			msg << "Unexpected key :'" << name << "'";
23513075c896SRyan Stone 			ATF_FAIL(msg.str().c_str());
23523075c896SRyan Stone 		}
23533075c896SRyan Stone 
23543075c896SRyan Stone 		keys_seen.insert(name);
23553075c896SRyan Stone 	}
23563075c896SRyan Stone 
23573075c896SRyan Stone 	/* Ensure that we saw every key. */
23583075c896SRyan Stone 	ATF_REQUIRE_EQ(keys_seen.size(), 5);
23593075c896SRyan Stone 
23603075c896SRyan Stone 	nvlist_destroy(nvl);
23613075c896SRyan Stone 	nvlist_destroy(unpacked);
23623075c896SRyan Stone 	free(packed);
23633075c896SRyan Stone }
23643075c896SRyan Stone 
23653075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__duplicate_key);
23663075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_unpack__duplicate_key)
23673075c896SRyan Stone {
23683075c896SRyan Stone 	nvlist_t *nvl, *unpacked;
23693075c896SRyan Stone 	const char *key1, *key2;
23703075c896SRyan Stone 	void *packed, *keypos;
23713075c896SRyan Stone 	size_t size, keylen;
23723075c896SRyan Stone 
23733075c896SRyan Stone 	nvl = nvlist_create(0);
23743075c896SRyan Stone 
23753075c896SRyan Stone 	key1 = "key1";
23763075c896SRyan Stone 	keylen = strlen(key1);
23773075c896SRyan Stone 	nvlist_add_number(nvl, key1, 5);
23783075c896SRyan Stone 
23793075c896SRyan Stone 	key2 = "key2";
23803075c896SRyan Stone 	ATF_REQUIRE_EQ(keylen, strlen(key2));
23813075c896SRyan Stone 	nvlist_add_number(nvl, key2, 10);
23823075c896SRyan Stone 
23833075c896SRyan Stone 	packed = nvlist_pack(nvl, &size);
23843075c896SRyan Stone 
23853075c896SRyan Stone 	/*
23863075c896SRyan Stone 	 * Mangle the packed nvlist by replacing key1 with key2, creating a
23873075c896SRyan Stone 	 * packed nvlist with a duplicate key.
23883075c896SRyan Stone 	 */
23893075c896SRyan Stone 	keypos = memmem(packed, size, key1, keylen);
23903075c896SRyan Stone 	ATF_REQUIRE(keypos != NULL);
23913075c896SRyan Stone 	memcpy(keypos, key2, keylen);
23923075c896SRyan Stone 
23933075c896SRyan Stone 	unpacked = nvlist_unpack(packed, size);
23943075c896SRyan Stone 	ATF_REQUIRE(nvlist_error(unpacked) != 0);
23953075c896SRyan Stone 
23963075c896SRyan Stone 	free(packed);
23973075c896SRyan Stone 	nvlist_destroy(nvl);
23983075c896SRyan Stone 	nvlist_destroy(unpacked);
23993075c896SRyan Stone }
24003075c896SRyan Stone 
24013075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_string__single_insert);
24023075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_move_string__single_insert)
24033075c896SRyan Stone {
24043075c896SRyan Stone 	nvlist_t *nvl;
24053075c896SRyan Stone 	const char *key;
24063075c896SRyan Stone 	char *value;
24073075c896SRyan Stone 
24083075c896SRyan Stone 	nvl = nvlist_create(0);
24093075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
24103075c896SRyan Stone 
24113075c896SRyan Stone 	key = "testkey";
24123075c896SRyan Stone 	value = strdup("testval");
24133075c896SRyan Stone 	ATF_REQUIRE(value != NULL);
24143075c896SRyan Stone 
24153075c896SRyan Stone 	nvlist_move_string(nvl, key, value);
24163075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_string(nvl, key), value);
24173075c896SRyan Stone 
24183075c896SRyan Stone 	nvlist_destroy(nvl);
24193075c896SRyan Stone }
24203075c896SRyan Stone 
24213075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__null_child);
24223075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_move_nvlist__null_child)
24233075c896SRyan Stone {
24243075c896SRyan Stone 	nvlist_t *parent;
24253075c896SRyan Stone 
24263075c896SRyan Stone 	parent = nvlist_create(0);
24273075c896SRyan Stone 
24283075c896SRyan Stone 	nvlist_move_nvlist(parent, "test", NULL);
24293075c896SRyan Stone 
24303075c896SRyan Stone 	ATF_REQUIRE(nvlist_error(parent) != 0);
24313075c896SRyan Stone 
24323075c896SRyan Stone 	nvlist_destroy(parent);
24333075c896SRyan Stone }
24343075c896SRyan Stone 
24353075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__single_insert);
24363075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_move_nvlist__single_insert)
24373075c896SRyan Stone {
24383075c896SRyan Stone 	nvlist_t *nvl;
24393075c896SRyan Stone 	const char *key;
24403075c896SRyan Stone 	nvlist_t *value;
24413075c896SRyan Stone 
24423075c896SRyan Stone 	nvl = nvlist_create(0);
24433075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
24443075c896SRyan Stone 
24453075c896SRyan Stone 	key = "testkey";
24463075c896SRyan Stone 	value = nvlist_create(0);
24473075c896SRyan Stone 	ATF_REQUIRE(value != NULL);
24483075c896SRyan Stone 
24493075c896SRyan Stone 	nvlist_move_nvlist(nvl, key, value);
24503075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_nvlist(nvl, key), value);
24513075c896SRyan Stone 
24523075c896SRyan Stone 	nvlist_destroy(nvl);
24533075c896SRyan Stone }
24543075c896SRyan Stone 
24553075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_binary__single_insert);
24563075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_move_binary__single_insert)
24573075c896SRyan Stone {
24583075c896SRyan Stone 	nvlist_t *nvl;
24593075c896SRyan Stone 	const char *key;
24603075c896SRyan Stone 	void *value;
24613075c896SRyan Stone 	size_t size, actual_size;
24623075c896SRyan Stone 
24633075c896SRyan Stone 	nvl = nvlist_create(0);
24643075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
24653075c896SRyan Stone 
24663075c896SRyan Stone 	key = "testkey";
24673075c896SRyan Stone 	size = 73;
24683075c896SRyan Stone 	value = malloc(size);
24693075c896SRyan Stone 	ATF_REQUIRE(value != NULL);
24703075c896SRyan Stone 
24713075c896SRyan Stone 	nvlist_move_binary(nvl, key, value, size);
24723075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_binary(nvl, key, &actual_size), value);
24733075c896SRyan Stone 	ATF_REQUIRE_EQ(size, actual_size);
24743075c896SRyan Stone 
24753075c896SRyan Stone 	nvlist_destroy(nvl);
24763075c896SRyan Stone }
24773075c896SRyan Stone 
24783075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__single_remove);
24793075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_bool__single_remove)
24803075c896SRyan Stone {
24813075c896SRyan Stone 	nvlist_t *nvl;
24823075c896SRyan Stone 	const char *testkey;
24833075c896SRyan Stone 	bool testval;
24843075c896SRyan Stone 
24853075c896SRyan Stone 	nvl = nvlist_create(0);
24863075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
24873075c896SRyan Stone 
24883075c896SRyan Stone 	testkey = "boolkey";
24893075c896SRyan Stone 	testval = false;
24903075c896SRyan Stone 	nvlist_add_bool(nvl, testkey, testval);
24913075c896SRyan Stone 
24923075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
24933075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
24943075c896SRyan Stone 
24953075c896SRyan Stone 	nvlist_destroy(nvl);
24963075c896SRyan Stone }
24973075c896SRyan Stone 
24983075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__other_keys_unchanged);
24993075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_bool__other_keys_unchanged)
25003075c896SRyan Stone {
25013075c896SRyan Stone 	nvlist_t *nvl;
25023075c896SRyan Stone 	const char *testkey, *otherkey1, *otherkey2;
25033075c896SRyan Stone 	bool testval, otherval1;
25043075c896SRyan Stone 	nvlist_t *otherval2;
25053075c896SRyan Stone 
25063075c896SRyan Stone 	nvl = nvlist_create(0);
25073075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
25083075c896SRyan Stone 
25093075c896SRyan Stone 	testkey = "boolkey";
25103075c896SRyan Stone 	testval = true;
25113075c896SRyan Stone 	nvlist_add_bool(nvl, testkey, testval);
25123075c896SRyan Stone 
25133075c896SRyan Stone 	otherkey1 = "key1";
25143075c896SRyan Stone 	otherval1 = false;
25153075c896SRyan Stone 	nvlist_add_bool(nvl, otherkey1, otherval1);
25163075c896SRyan Stone 
25173075c896SRyan Stone 	otherkey2 = "key2";
25183075c896SRyan Stone 	otherval2 = create_test_nvlist();
25193075c896SRyan Stone 	nvlist_move_nvlist(nvl, otherkey2, otherval2);
25203075c896SRyan Stone 
25213075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
25223075c896SRyan Stone 
25233075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey1));
25243075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey1), otherval1);
25253075c896SRyan Stone 
25263075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey2));
25273075c896SRyan Stone 	verify_test_nvlist(nvlist_get_nvlist(nvl, otherkey2));
25283075c896SRyan Stone 
25293075c896SRyan Stone 	nvlist_destroy(nvl);
25303075c896SRyan Stone }
25313075c896SRyan Stone 
25323075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__single_remove);
25333075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_number__single_remove)
25343075c896SRyan Stone {
25353075c896SRyan Stone 	nvlist_t *nvl;
25363075c896SRyan Stone 	const char *testkey;
25373075c896SRyan Stone 	uint64_t testval;
25383075c896SRyan Stone 
25393075c896SRyan Stone 	nvl = nvlist_create(0);
25403075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
25413075c896SRyan Stone 
25423075c896SRyan Stone 	testkey = "numkey";
25433075c896SRyan Stone 	testval = std::numeric_limits<uint64_t>::max();
25443075c896SRyan Stone 	nvlist_add_number(nvl, testkey, testval);
25453075c896SRyan Stone 
25463075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
25473075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
25483075c896SRyan Stone 
25493075c896SRyan Stone 	nvlist_destroy(nvl);
25503075c896SRyan Stone }
25513075c896SRyan Stone 
25523075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__other_keys_unchanged);
25533075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_number__other_keys_unchanged)
25543075c896SRyan Stone {
25553075c896SRyan Stone 	nvlist_t *nvl;
25563075c896SRyan Stone 	const char *testkey, *otherkey1, *otherkey2;
25573075c896SRyan Stone 	uint64_t testval, otherval1;
25583075c896SRyan Stone 	const char *otherval2;
25593075c896SRyan Stone 
25603075c896SRyan Stone 	nvl = nvlist_create(0);
25613075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
25623075c896SRyan Stone 
25633075c896SRyan Stone 	otherkey1 = "key1";
25643075c896SRyan Stone 	otherval1 = 5;
25653075c896SRyan Stone 	nvlist_add_number(nvl, otherkey1, otherval1);
25663075c896SRyan Stone 
25673075c896SRyan Stone 	testkey = "numkey";
25683075c896SRyan Stone 	testval = 1654;
25693075c896SRyan Stone 	nvlist_add_number(nvl, testkey, testval);
25703075c896SRyan Stone 
25713075c896SRyan Stone 	otherkey2 = "key2";
25723075c896SRyan Stone 	otherval2 = "string";
25733075c896SRyan Stone 	nvlist_add_string(nvl, otherkey2, otherval2);
25743075c896SRyan Stone 
25753075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
25763075c896SRyan Stone 
25773075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_number(nvl, otherkey1));
25783075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_number(nvl, otherkey1), otherval1);
25793075c896SRyan Stone 
25803075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey2));
25813075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey2), otherval2), 0);
25823075c896SRyan Stone 
25833075c896SRyan Stone 	nvlist_destroy(nvl);
25843075c896SRyan Stone }
25853075c896SRyan Stone 
25863075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__single_remove);
25873075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_string__single_remove)
25883075c896SRyan Stone {
25893075c896SRyan Stone 	nvlist_t *nvl;
25903075c896SRyan Stone 	const char *testkey;
25913075c896SRyan Stone 	const char *testval;
25923075c896SRyan Stone 
25933075c896SRyan Stone 	nvl = nvlist_create(0);
25943075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
25953075c896SRyan Stone 
25963075c896SRyan Stone 	testkey = "numkey";
25973075c896SRyan Stone 	testval = "nvlist";
25983075c896SRyan Stone 	nvlist_add_string(nvl, testkey, testval);
25993075c896SRyan Stone 
26003075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
26013075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
26023075c896SRyan Stone 
26033075c896SRyan Stone 	nvlist_destroy(nvl);
26043075c896SRyan Stone }
26053075c896SRyan Stone 
26063075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__other_keys_unchanged);
26073075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_string__other_keys_unchanged)
26083075c896SRyan Stone {
26093075c896SRyan Stone 	nvlist_t *nvl;
26103075c896SRyan Stone 	const char *testkey, *otherkey1, *otherkey2;
26113075c896SRyan Stone 	const char *testval, *otherval1;
26123075c896SRyan Stone 	bool otherval2;
26133075c896SRyan Stone 
26143075c896SRyan Stone 	nvl = nvlist_create(0);
26153075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
26163075c896SRyan Stone 
26173075c896SRyan Stone 	otherkey1 = "key1";
26183075c896SRyan Stone 	otherval1 = "fjdifjdk";
26193075c896SRyan Stone 	nvlist_add_string(nvl, otherkey1, otherval1);
26203075c896SRyan Stone 
26213075c896SRyan Stone 	otherkey2 = "key2";
26223075c896SRyan Stone 	otherval2 = true;
26233075c896SRyan Stone 	nvlist_add_bool(nvl, otherkey2, otherval2);
26243075c896SRyan Stone 
26253075c896SRyan Stone 	testkey = "strkey";
26263075c896SRyan Stone 	testval = "1654";
26273075c896SRyan Stone 	nvlist_add_string(nvl, testkey, testval);
26283075c896SRyan Stone 
26293075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
26303075c896SRyan Stone 
26313075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey1));
26323075c896SRyan Stone 	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey1), otherval1), 0);
26333075c896SRyan Stone 
26343075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
26353075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
26363075c896SRyan Stone 
26373075c896SRyan Stone 	nvlist_destroy(nvl);
26383075c896SRyan Stone }
26393075c896SRyan Stone 
26403075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__single_remove);
26413075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_nvlist__single_remove)
26423075c896SRyan Stone {
26433075c896SRyan Stone 	nvlist_t *nvl;
26443075c896SRyan Stone 	const char *testkey;
26453075c896SRyan Stone 	nvlist_t *testval;
26463075c896SRyan Stone 
26473075c896SRyan Stone 	nvl = nvlist_create(0);
26483075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
26493075c896SRyan Stone 
26503075c896SRyan Stone 	testkey = "numkey";
26513075c896SRyan Stone 	testval = create_test_nvlist();
26523075c896SRyan Stone 	nvlist_move_nvlist(nvl, testkey, testval);
26533075c896SRyan Stone 
26543075c896SRyan Stone 	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
26553075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
26563075c896SRyan Stone 
26573075c896SRyan Stone 	nvlist_destroy(nvl);
26583075c896SRyan Stone }
26593075c896SRyan Stone 
26603075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__other_keys_unchanged);
26613075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_nvlist__other_keys_unchanged)
26623075c896SRyan Stone {
26633075c896SRyan Stone 	nvlist_t *nvl;
26643075c896SRyan Stone 	const char *testkey, *otherkey1, *otherkey2;
26653075c896SRyan Stone 	nvlist_t *testval, *otherval1;
26663075c896SRyan Stone 
26673075c896SRyan Stone 	nvl = nvlist_create(0);
26683075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
26693075c896SRyan Stone 
26703075c896SRyan Stone 	testkey = "strkey";
26713075c896SRyan Stone 	testval = create_test_nvlist();
26723075c896SRyan Stone 	nvlist_move_nvlist(nvl, testkey, testval);
26733075c896SRyan Stone 
26743075c896SRyan Stone 	otherkey1 = "key1";
26753075c896SRyan Stone 	otherval1 = nvlist_create(0);
26763075c896SRyan Stone 	nvlist_move_nvlist(nvl, otherkey1, otherval1);
26773075c896SRyan Stone 
26783075c896SRyan Stone 	otherkey2 = "key2";
26793075c896SRyan Stone 	nvlist_add_null(nvl, otherkey2);
26803075c896SRyan Stone 
26813075c896SRyan Stone 	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
26823075c896SRyan Stone 
26833075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey1));
26843075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvlist_get_nvlist(nvl, otherkey1)));
26853075c896SRyan Stone 
26863075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_null(nvl, otherkey2));
26873075c896SRyan Stone 
26883075c896SRyan Stone 	nvlist_destroy(nvl);
26893075c896SRyan Stone }
26903075c896SRyan Stone 
26913075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__single_remove);
26923075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_binary__single_remove)
26933075c896SRyan Stone {
26943075c896SRyan Stone 	nvlist_t *nvl;
26953075c896SRyan Stone 	const char *testkey;
26963075c896SRyan Stone 	void *testval;
26973075c896SRyan Stone 	const void *actual_val;
26983075c896SRyan Stone 	size_t testsize, actual_size;
26993075c896SRyan Stone 
27003075c896SRyan Stone 	nvl = nvlist_create(0);
27013075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
27023075c896SRyan Stone 
27033075c896SRyan Stone 	testkey = "numkey";
27043075c896SRyan Stone 	testsize = 457;
27053075c896SRyan Stone 	testval = malloc(testsize);
27063075c896SRyan Stone 	memset(testval, '5', testsize);
27073075c896SRyan Stone 	nvlist_move_binary(nvl, testkey, testval, testsize);
27083075c896SRyan Stone 
27093075c896SRyan Stone 	actual_val = nvlist_take_binary(nvl, testkey, &actual_size);
27103075c896SRyan Stone 	ATF_REQUIRE_EQ(testsize, actual_size);
27113075c896SRyan Stone 	ATF_REQUIRE_EQ(memcmp(actual_val, testval, testsize), 0);
27123075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
27133075c896SRyan Stone 
27143075c896SRyan Stone 	nvlist_destroy(nvl);
27153075c896SRyan Stone }
27163075c896SRyan Stone 
27173075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__other_keys_unchanged);
27183075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_take_binary__other_keys_unchanged)
27193075c896SRyan Stone {
27203075c896SRyan Stone 	nvlist_t *nvl;
27213075c896SRyan Stone 	const char *testkey, *otherkey1, *otherkey2;
27223075c896SRyan Stone 	const void *actual_value;
27233075c896SRyan Stone 	char testval[] = "gjiertj";
27243075c896SRyan Stone 	char otherval1[] = "fdreg";
27253075c896SRyan Stone 	size_t testsize, othersize, actual_size;
27263075c896SRyan Stone 	bool otherval2;
27273075c896SRyan Stone 
27283075c896SRyan Stone 	nvl = nvlist_create(0);
27293075c896SRyan Stone 	ATF_REQUIRE(nvl != NULL);
27303075c896SRyan Stone 
27313075c896SRyan Stone 	otherkey1 = "key1";
27323075c896SRyan Stone 	othersize = sizeof(otherval1);
27333075c896SRyan Stone 	nvlist_add_binary(nvl, otherkey1, otherval1, othersize);
27343075c896SRyan Stone 
27353075c896SRyan Stone 	otherkey2 = "key2";
27363075c896SRyan Stone 	otherval2 = true;
27373075c896SRyan Stone 	nvlist_add_bool(nvl, otherkey2, otherval2);
27383075c896SRyan Stone 
27393075c896SRyan Stone 	testkey = "strkey";
27403075c896SRyan Stone 	testsize = sizeof(testval);
27413075c896SRyan Stone 	nvlist_add_binary(nvl, testkey, testval, testsize);
27423075c896SRyan Stone 
27433075c896SRyan Stone 	actual_value = nvlist_take_binary(nvl, testkey, &actual_size);
27443075c896SRyan Stone 	ATF_REQUIRE_EQ(testsize, actual_size);
27453075c896SRyan Stone 	ATF_REQUIRE_EQ(memcmp(actual_value, testval, testsize), 0);
27463075c896SRyan Stone 
27473075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_binary(nvl, otherkey1));
27483075c896SRyan Stone 	actual_value = nvlist_get_binary(nvl, otherkey1, &actual_size);
27493075c896SRyan Stone 	ATF_REQUIRE_EQ(othersize, actual_size);
27503075c896SRyan Stone 	ATF_REQUIRE_EQ(memcmp(actual_value, otherval1, othersize), 0);
27513075c896SRyan Stone 
27523075c896SRyan Stone 	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
27533075c896SRyan Stone 	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
27543075c896SRyan Stone 
27553075c896SRyan Stone 	nvlist_destroy(nvl);
27563075c896SRyan Stone }
27573075c896SRyan Stone 
27583075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_null);
27593075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_free__single_null)
27603075c896SRyan Stone {
27613075c896SRyan Stone 	nvlist_t *nvl;
27623075c896SRyan Stone 	const char *key;
27633075c896SRyan Stone 
27643075c896SRyan Stone 	nvl = nvlist_create(0);
27653075c896SRyan Stone 	key = "test";
27663075c896SRyan Stone 	nvlist_add_null(nvl, key);
27673075c896SRyan Stone 
27683075c896SRyan Stone 	nvlist_free(nvl, key);
27693075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
27703075c896SRyan Stone 
27713075c896SRyan Stone 	nvlist_destroy(nvl);
27723075c896SRyan Stone }
27733075c896SRyan Stone 
27743075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_bool);
27753075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_free__single_bool)
27763075c896SRyan Stone {
27773075c896SRyan Stone 	nvlist_t *nvl;
27783075c896SRyan Stone 	const char *key;
27793075c896SRyan Stone 
27803075c896SRyan Stone 	nvl = nvlist_create(0);
27813075c896SRyan Stone 	key = "test";
27823075c896SRyan Stone 	nvlist_add_bool(nvl, key, true);
27833075c896SRyan Stone 
27843075c896SRyan Stone 	nvlist_free(nvl, key);
27853075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
27863075c896SRyan Stone 
27873075c896SRyan Stone 	nvlist_destroy(nvl);
27883075c896SRyan Stone }
27893075c896SRyan Stone 
27903075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_number);
27913075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_free__single_number)
27923075c896SRyan Stone {
27933075c896SRyan Stone 	nvlist_t *nvl;
27943075c896SRyan Stone 	const char *key;
27953075c896SRyan Stone 
27963075c896SRyan Stone 	nvl = nvlist_create(0);
27973075c896SRyan Stone 	key = "test";
27983075c896SRyan Stone 	nvlist_add_number(nvl, key, 584);
27993075c896SRyan Stone 
28003075c896SRyan Stone 	nvlist_free(nvl, key);
28013075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
28023075c896SRyan Stone 
28033075c896SRyan Stone 	nvlist_destroy(nvl);
28043075c896SRyan Stone }
28053075c896SRyan Stone 
28063075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_string);
28073075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_free__single_string)
28083075c896SRyan Stone {
28093075c896SRyan Stone 	nvlist_t *nvl;
28103075c896SRyan Stone 	const char *key;
28113075c896SRyan Stone 
28123075c896SRyan Stone 	nvl = nvlist_create(0);
28133075c896SRyan Stone 	key = "test";
28143075c896SRyan Stone 	nvlist_add_string(nvl, key, "gjkfkjd");
28153075c896SRyan Stone 
28163075c896SRyan Stone 	nvlist_free(nvl, key);
28173075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
28183075c896SRyan Stone 
28193075c896SRyan Stone 	nvlist_destroy(nvl);
28203075c896SRyan Stone }
28213075c896SRyan Stone 
28223075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_nvlist);
28233075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_free__single_nvlist)
28243075c896SRyan Stone {
28253075c896SRyan Stone 	nvlist_t *nvl;
28263075c896SRyan Stone 	const char *key;
28273075c896SRyan Stone 
28283075c896SRyan Stone 	nvl = nvlist_create(0);
28293075c896SRyan Stone 	key = "test";
28303075c896SRyan Stone 	nvlist_add_nvlist(nvl, key, nvlist_create(0));
28313075c896SRyan Stone 
28323075c896SRyan Stone 	nvlist_free(nvl, key);
28333075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
28343075c896SRyan Stone 
28353075c896SRyan Stone 	nvlist_destroy(nvl);
28363075c896SRyan Stone }
28373075c896SRyan Stone 
28383075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_binary);
28393075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_free__single_binary)
28403075c896SRyan Stone {
28413075c896SRyan Stone 	nvlist_t *nvl;
28423075c896SRyan Stone 	const char *key;
28433075c896SRyan Stone 
28443075c896SRyan Stone 	nvl = nvlist_create(0);
28453075c896SRyan Stone 	key = "test";
28463075c896SRyan Stone 	nvlist_add_binary(nvl, key, "jgjgfd", 6);
28473075c896SRyan Stone 
28483075c896SRyan Stone 	nvlist_free(nvl, key);
28493075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
28503075c896SRyan Stone 
28513075c896SRyan Stone 	nvlist_destroy(nvl);
28523075c896SRyan Stone }
28533075c896SRyan Stone 
28543075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_null__single_null);
28553075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_free_null__single_null)
28563075c896SRyan Stone {
28573075c896SRyan Stone 	nvlist_t *nvl;
28583075c896SRyan Stone 	const char *key;
28593075c896SRyan Stone 
28603075c896SRyan Stone 	nvl = nvlist_create(0);
28613075c896SRyan Stone 	key = "test";
28623075c896SRyan Stone 	nvlist_add_null(nvl, key);
28633075c896SRyan Stone 
28643075c896SRyan Stone 	nvlist_free_null(nvl, key);
28653075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
28663075c896SRyan Stone 
28673075c896SRyan Stone 	nvlist_destroy(nvl);
28683075c896SRyan Stone }
28693075c896SRyan Stone 
28703075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_bool__single_bool);
28713075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_free_bool__single_bool)
28723075c896SRyan Stone {
28733075c896SRyan Stone 	nvlist_t *nvl;
28743075c896SRyan Stone 	const char *key;
28753075c896SRyan Stone 
28763075c896SRyan Stone 	nvl = nvlist_create(0);
28773075c896SRyan Stone 	key = "test";
28783075c896SRyan Stone 	nvlist_add_bool(nvl, key, true);
28793075c896SRyan Stone 
28803075c896SRyan Stone 	nvlist_free_bool(nvl, key);
28813075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
28823075c896SRyan Stone 
28833075c896SRyan Stone 	nvlist_destroy(nvl);
28843075c896SRyan Stone }
28853075c896SRyan Stone 
28863075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_number__single_number);
28873075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_free_number__single_number)
28883075c896SRyan Stone {
28893075c896SRyan Stone 	nvlist_t *nvl;
28903075c896SRyan Stone 	const char *key;
28913075c896SRyan Stone 
28923075c896SRyan Stone 	nvl = nvlist_create(0);
28933075c896SRyan Stone 	key = "test";
28943075c896SRyan Stone 	nvlist_add_number(nvl, key, 584);
28953075c896SRyan Stone 
28963075c896SRyan Stone 	nvlist_free_number(nvl, key);
28973075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
28983075c896SRyan Stone 
28993075c896SRyan Stone 	nvlist_destroy(nvl);
29003075c896SRyan Stone }
29013075c896SRyan Stone 
29023075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_string__single_string);
29033075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_free_string__single_string)
29043075c896SRyan Stone {
29053075c896SRyan Stone 	nvlist_t *nvl;
29063075c896SRyan Stone 	const char *key;
29073075c896SRyan Stone 
29083075c896SRyan Stone 	nvl = nvlist_create(0);
29093075c896SRyan Stone 	key = "test";
29103075c896SRyan Stone 	nvlist_add_string(nvl, key, "gjkfkjd");
29113075c896SRyan Stone 
29123075c896SRyan Stone 	nvlist_free_string(nvl, key);
29133075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
29143075c896SRyan Stone 
29153075c896SRyan Stone 	nvlist_destroy(nvl);
29163075c896SRyan Stone }
29173075c896SRyan Stone 
29183075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_nvlist__single_nvlist);
29193075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_free_nvlist__single_nvlist)
29203075c896SRyan Stone {
29213075c896SRyan Stone 	nvlist_t *nvl;
29223075c896SRyan Stone 	const char *key;
29233075c896SRyan Stone 
29243075c896SRyan Stone 	nvl = nvlist_create(0);
29253075c896SRyan Stone 	key = "test";
29263075c896SRyan Stone 	nvlist_add_nvlist(nvl, key, nvlist_create(0));
29273075c896SRyan Stone 
29283075c896SRyan Stone 	nvlist_free_nvlist(nvl, key);
29293075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
29303075c896SRyan Stone 
29313075c896SRyan Stone 	nvlist_destroy(nvl);
29323075c896SRyan Stone }
29333075c896SRyan Stone 
29343075c896SRyan Stone ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_binary__single_binary);
29353075c896SRyan Stone ATF_TEST_CASE_BODY(nvlist_free_binary__single_binary)
29363075c896SRyan Stone {
29373075c896SRyan Stone 	nvlist_t *nvl;
29383075c896SRyan Stone 	const char *key;
29393075c896SRyan Stone 
29403075c896SRyan Stone 	nvl = nvlist_create(0);
29413075c896SRyan Stone 	key = "test";
29423075c896SRyan Stone 	nvlist_add_binary(nvl, key, "jgjgfd", 6);
29433075c896SRyan Stone 
29443075c896SRyan Stone 	nvlist_free_binary(nvl, key);
29453075c896SRyan Stone 	ATF_REQUIRE(nvlist_empty(nvl));
29463075c896SRyan Stone 
29473075c896SRyan Stone 	nvlist_destroy(nvl);
29483075c896SRyan Stone }
29493075c896SRyan Stone 
29503075c896SRyan Stone ATF_INIT_TEST_CASES(tp)
29513075c896SRyan Stone {
29523075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty);
29533075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert);
29543075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert);
29553075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert);
29563075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert);
29573075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert);
29583075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert);
29593075c896SRyan Stone 
29603075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_clone__empty_nvlist);
29613075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_clone__nonempty_nvlist);
29623075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_clone__nested_nvlist);
29633075c896SRyan Stone 
29643075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_pack__empty_nvlist);
29653075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_pack__multiple_values);
29663075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_unpack__duplicate_key);
29673075c896SRyan Stone 
29683075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_move_string__single_insert);
29693075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__single_insert);
29703075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__null_child);
29713075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_move_binary__single_insert);
29723075c896SRyan Stone 
29733075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__single_remove);
29743075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__other_keys_unchanged);
29753075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_number__single_remove);
29763075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_number__other_keys_unchanged);
29773075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_string__single_remove);
29783075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_string__other_keys_unchanged);
29793075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__single_remove);
29803075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__other_keys_unchanged);
29813075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__single_remove);
29823075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__other_keys_unchanged);
29833075c896SRyan Stone 
29843075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free__single_null);
29853075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free__single_bool);
29863075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free__single_number);
29873075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free__single_string);
29883075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free__single_nvlist);
29893075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free__single_binary);
29903075c896SRyan Stone 
29913075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free_null__single_null);
29923075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free_bool__single_bool);
29933075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free_number__single_number);
29943075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free_string__single_string);
29953075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free_nvlist__single_nvlist);
29963075c896SRyan Stone 	ATF_ADD_TEST_CASE(tp, nvlist_free_binary__single_binary);
29973075c896SRyan Stone }
2998