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