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